strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    __slots__ = [
   23        'bind_interface',
   24        'certificate_authority',
   25        'client_certificate',
   26        'client_key',
   27        'egress_filter',
   28        'healthcheck_namespace',
   29        'healthy',
   30        'hostname',
   31        'id',
   32        'name',
   33        'port',
   34        'port_override',
   35        'remote_identity_group_id',
   36        'remote_identity_healthcheck_username',
   37        'secret_store_id',
   38        'tags',
   39    ]
   40
   41    def __init__(
   42        self,
   43        bind_interface=None,
   44        certificate_authority=None,
   45        client_certificate=None,
   46        client_key=None,
   47        egress_filter=None,
   48        healthcheck_namespace=None,
   49        healthy=None,
   50        hostname=None,
   51        id=None,
   52        name=None,
   53        port=None,
   54        port_override=None,
   55        remote_identity_group_id=None,
   56        remote_identity_healthcheck_username=None,
   57        secret_store_id=None,
   58        tags=None,
   59    ):
   60        self.bind_interface = bind_interface if bind_interface is not None else ''
   61        '''
   62         Bind interface
   63        '''
   64        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   65        self.client_certificate = client_certificate if client_certificate is not None else ''
   66        self.client_key = client_key if client_key is not None else ''
   67        self.egress_filter = egress_filter if egress_filter is not None else ''
   68        '''
   69         A filter applied to the routing logic to pin datasource to nodes.
   70        '''
   71        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   72        '''
   73         The path used to check the health of your connection.  Defaults to `default`.
   74        '''
   75        self.healthy = healthy if healthy is not None else False
   76        '''
   77         True if the datasource is reachable and the credentials are valid.
   78        '''
   79        self.hostname = hostname if hostname is not None else ''
   80        self.id = id if id is not None else ''
   81        '''
   82         Unique identifier of the Resource.
   83        '''
   84        self.name = name if name is not None else ''
   85        '''
   86         Unique human-readable name of the Resource.
   87        '''
   88        self.port = port if port is not None else 0
   89        self.port_override = port_override if port_override is not None else 0
   90        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
   91        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
   92        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
   93        '''
   94         ID of the secret store containing credentials for this resource, if any.
   95        '''
   96        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
   97        '''
   98         Tags is a map of key, value pairs.
   99        '''
  100
  101    def __repr__(self):
  102        return '<sdm.AKS ' + \
  103            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  104            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  105            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  106            'client_key: ' + repr(self.client_key) + ' ' +\
  107            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  108            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  109            'healthy: ' + repr(self.healthy) + ' ' +\
  110            'hostname: ' + repr(self.hostname) + ' ' +\
  111            'id: ' + repr(self.id) + ' ' +\
  112            'name: ' + repr(self.name) + ' ' +\
  113            'port: ' + repr(self.port) + ' ' +\
  114            'port_override: ' + repr(self.port_override) + ' ' +\
  115            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  116            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  117            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  118            'tags: ' + repr(self.tags) + ' ' +\
  119            '>'
  120
  121    def to_dict(self):
  122        return {
  123            'bind_interface': self.bind_interface,
  124            'certificate_authority': self.certificate_authority,
  125            'client_certificate': self.client_certificate,
  126            'client_key': self.client_key,
  127            'egress_filter': self.egress_filter,
  128            'healthcheck_namespace': self.healthcheck_namespace,
  129            'healthy': self.healthy,
  130            'hostname': self.hostname,
  131            'id': self.id,
  132            'name': self.name,
  133            'port': self.port,
  134            'port_override': self.port_override,
  135            'remote_identity_group_id': self.remote_identity_group_id,
  136            'remote_identity_healthcheck_username':
  137            self.remote_identity_healthcheck_username,
  138            'secret_store_id': self.secret_store_id,
  139            'tags': self.tags,
  140        }
  141
  142    @classmethod
  143    def from_dict(cls, d):
  144        return cls(
  145            bind_interface=d.get('bind_interface'),
  146            certificate_authority=d.get('certificate_authority'),
  147            client_certificate=d.get('client_certificate'),
  148            client_key=d.get('client_key'),
  149            egress_filter=d.get('egress_filter'),
  150            healthcheck_namespace=d.get('healthcheck_namespace'),
  151            healthy=d.get('healthy'),
  152            hostname=d.get('hostname'),
  153            id=d.get('id'),
  154            name=d.get('name'),
  155            port=d.get('port'),
  156            port_override=d.get('port_override'),
  157            remote_identity_group_id=d.get('remote_identity_group_id'),
  158            remote_identity_healthcheck_username=d.get(
  159                'remote_identity_healthcheck_username'),
  160            secret_store_id=d.get('secret_store_id'),
  161            tags=d.get('tags'),
  162        )
  163
  164
  165class AKSBasicAuth:
  166    __slots__ = [
  167        'bind_interface',
  168        'egress_filter',
  169        'healthcheck_namespace',
  170        'healthy',
  171        'hostname',
  172        'id',
  173        'name',
  174        'password',
  175        'port',
  176        'port_override',
  177        'secret_store_id',
  178        'tags',
  179        'username',
  180    ]
  181
  182    def __init__(
  183        self,
  184        bind_interface=None,
  185        egress_filter=None,
  186        healthcheck_namespace=None,
  187        healthy=None,
  188        hostname=None,
  189        id=None,
  190        name=None,
  191        password=None,
  192        port=None,
  193        port_override=None,
  194        secret_store_id=None,
  195        tags=None,
  196        username=None,
  197    ):
  198        self.bind_interface = bind_interface if bind_interface is not None else ''
  199        '''
  200         Bind interface
  201        '''
  202        self.egress_filter = egress_filter if egress_filter is not None else ''
  203        '''
  204         A filter applied to the routing logic to pin datasource to nodes.
  205        '''
  206        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  207        '''
  208         The path used to check the health of your connection.  Defaults to `default`.
  209        '''
  210        self.healthy = healthy if healthy is not None else False
  211        '''
  212         True if the datasource is reachable and the credentials are valid.
  213        '''
  214        self.hostname = hostname if hostname is not None else ''
  215        self.id = id if id is not None else ''
  216        '''
  217         Unique identifier of the Resource.
  218        '''
  219        self.name = name if name is not None else ''
  220        '''
  221         Unique human-readable name of the Resource.
  222        '''
  223        self.password = password if password is not None else ''
  224        self.port = port if port is not None else 0
  225        self.port_override = port_override if port_override is not None else 0
  226        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  227        '''
  228         ID of the secret store containing credentials for this resource, if any.
  229        '''
  230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  231        '''
  232         Tags is a map of key, value pairs.
  233        '''
  234        self.username = username if username is not None else ''
  235
  236    def __repr__(self):
  237        return '<sdm.AKSBasicAuth ' + \
  238            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  239            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  240            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  241            'healthy: ' + repr(self.healthy) + ' ' +\
  242            'hostname: ' + repr(self.hostname) + ' ' +\
  243            'id: ' + repr(self.id) + ' ' +\
  244            'name: ' + repr(self.name) + ' ' +\
  245            'password: ' + repr(self.password) + ' ' +\
  246            'port: ' + repr(self.port) + ' ' +\
  247            'port_override: ' + repr(self.port_override) + ' ' +\
  248            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  249            'tags: ' + repr(self.tags) + ' ' +\
  250            'username: ' + repr(self.username) + ' ' +\
  251            '>'
  252
  253    def to_dict(self):
  254        return {
  255            'bind_interface': self.bind_interface,
  256            'egress_filter': self.egress_filter,
  257            'healthcheck_namespace': self.healthcheck_namespace,
  258            'healthy': self.healthy,
  259            'hostname': self.hostname,
  260            'id': self.id,
  261            'name': self.name,
  262            'password': self.password,
  263            'port': self.port,
  264            'port_override': self.port_override,
  265            'secret_store_id': self.secret_store_id,
  266            'tags': self.tags,
  267            'username': self.username,
  268        }
  269
  270    @classmethod
  271    def from_dict(cls, d):
  272        return cls(
  273            bind_interface=d.get('bind_interface'),
  274            egress_filter=d.get('egress_filter'),
  275            healthcheck_namespace=d.get('healthcheck_namespace'),
  276            healthy=d.get('healthy'),
  277            hostname=d.get('hostname'),
  278            id=d.get('id'),
  279            name=d.get('name'),
  280            password=d.get('password'),
  281            port=d.get('port'),
  282            port_override=d.get('port_override'),
  283            secret_store_id=d.get('secret_store_id'),
  284            tags=d.get('tags'),
  285            username=d.get('username'),
  286        )
  287
  288
  289class AKSServiceAccount:
  290    __slots__ = [
  291        'bind_interface',
  292        'egress_filter',
  293        'healthcheck_namespace',
  294        'healthy',
  295        'hostname',
  296        'id',
  297        'name',
  298        'port',
  299        'port_override',
  300        'remote_identity_group_id',
  301        'remote_identity_healthcheck_username',
  302        'secret_store_id',
  303        'tags',
  304        'token',
  305    ]
  306
  307    def __init__(
  308        self,
  309        bind_interface=None,
  310        egress_filter=None,
  311        healthcheck_namespace=None,
  312        healthy=None,
  313        hostname=None,
  314        id=None,
  315        name=None,
  316        port=None,
  317        port_override=None,
  318        remote_identity_group_id=None,
  319        remote_identity_healthcheck_username=None,
  320        secret_store_id=None,
  321        tags=None,
  322        token=None,
  323    ):
  324        self.bind_interface = bind_interface if bind_interface is not None else ''
  325        '''
  326         Bind interface
  327        '''
  328        self.egress_filter = egress_filter if egress_filter is not None else ''
  329        '''
  330         A filter applied to the routing logic to pin datasource to nodes.
  331        '''
  332        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  333        '''
  334         The path used to check the health of your connection.  Defaults to `default`.
  335        '''
  336        self.healthy = healthy if healthy is not None else False
  337        '''
  338         True if the datasource is reachable and the credentials are valid.
  339        '''
  340        self.hostname = hostname if hostname is not None else ''
  341        self.id = id if id is not None else ''
  342        '''
  343         Unique identifier of the Resource.
  344        '''
  345        self.name = name if name is not None else ''
  346        '''
  347         Unique human-readable name of the Resource.
  348        '''
  349        self.port = port if port is not None else 0
  350        self.port_override = port_override if port_override is not None else 0
  351        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  353        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  354        '''
  355         ID of the secret store containing credentials for this resource, if any.
  356        '''
  357        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  358        '''
  359         Tags is a map of key, value pairs.
  360        '''
  361        self.token = token if token is not None else ''
  362
  363    def __repr__(self):
  364        return '<sdm.AKSServiceAccount ' + \
  365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  367            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  368            'healthy: ' + repr(self.healthy) + ' ' +\
  369            'hostname: ' + repr(self.hostname) + ' ' +\
  370            'id: ' + repr(self.id) + ' ' +\
  371            'name: ' + repr(self.name) + ' ' +\
  372            'port: ' + repr(self.port) + ' ' +\
  373            'port_override: ' + repr(self.port_override) + ' ' +\
  374            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  375            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  376            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  377            'tags: ' + repr(self.tags) + ' ' +\
  378            'token: ' + repr(self.token) + ' ' +\
  379            '>'
  380
  381    def to_dict(self):
  382        return {
  383            'bind_interface': self.bind_interface,
  384            'egress_filter': self.egress_filter,
  385            'healthcheck_namespace': self.healthcheck_namespace,
  386            'healthy': self.healthy,
  387            'hostname': self.hostname,
  388            'id': self.id,
  389            'name': self.name,
  390            'port': self.port,
  391            'port_override': self.port_override,
  392            'remote_identity_group_id': self.remote_identity_group_id,
  393            'remote_identity_healthcheck_username':
  394            self.remote_identity_healthcheck_username,
  395            'secret_store_id': self.secret_store_id,
  396            'tags': self.tags,
  397            'token': self.token,
  398        }
  399
  400    @classmethod
  401    def from_dict(cls, d):
  402        return cls(
  403            bind_interface=d.get('bind_interface'),
  404            egress_filter=d.get('egress_filter'),
  405            healthcheck_namespace=d.get('healthcheck_namespace'),
  406            healthy=d.get('healthy'),
  407            hostname=d.get('hostname'),
  408            id=d.get('id'),
  409            name=d.get('name'),
  410            port=d.get('port'),
  411            port_override=d.get('port_override'),
  412            remote_identity_group_id=d.get('remote_identity_group_id'),
  413            remote_identity_healthcheck_username=d.get(
  414                'remote_identity_healthcheck_username'),
  415            secret_store_id=d.get('secret_store_id'),
  416            tags=d.get('tags'),
  417            token=d.get('token'),
  418        )
  419
  420
  421class AKSServiceAccountUserImpersonation:
  422    __slots__ = [
  423        'bind_interface',
  424        'egress_filter',
  425        'healthcheck_namespace',
  426        'healthy',
  427        'hostname',
  428        'id',
  429        'name',
  430        'port',
  431        'port_override',
  432        'secret_store_id',
  433        'tags',
  434        'token',
  435    ]
  436
  437    def __init__(
  438        self,
  439        bind_interface=None,
  440        egress_filter=None,
  441        healthcheck_namespace=None,
  442        healthy=None,
  443        hostname=None,
  444        id=None,
  445        name=None,
  446        port=None,
  447        port_override=None,
  448        secret_store_id=None,
  449        tags=None,
  450        token=None,
  451    ):
  452        self.bind_interface = bind_interface if bind_interface is not None else ''
  453        '''
  454         Bind interface
  455        '''
  456        self.egress_filter = egress_filter if egress_filter is not None else ''
  457        '''
  458         A filter applied to the routing logic to pin datasource to nodes.
  459        '''
  460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  461        '''
  462         The path used to check the health of your connection.  Defaults to `default`.
  463        '''
  464        self.healthy = healthy if healthy is not None else False
  465        '''
  466         True if the datasource is reachable and the credentials are valid.
  467        '''
  468        self.hostname = hostname if hostname is not None else ''
  469        self.id = id if id is not None else ''
  470        '''
  471         Unique identifier of the Resource.
  472        '''
  473        self.name = name if name is not None else ''
  474        '''
  475         Unique human-readable name of the Resource.
  476        '''
  477        self.port = port if port is not None else 0
  478        self.port_override = port_override if port_override is not None else 0
  479        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  480        '''
  481         ID of the secret store containing credentials for this resource, if any.
  482        '''
  483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  484        '''
  485         Tags is a map of key, value pairs.
  486        '''
  487        self.token = token if token is not None else ''
  488
  489    def __repr__(self):
  490        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  491            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  492            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  493            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  494            'healthy: ' + repr(self.healthy) + ' ' +\
  495            'hostname: ' + repr(self.hostname) + ' ' +\
  496            'id: ' + repr(self.id) + ' ' +\
  497            'name: ' + repr(self.name) + ' ' +\
  498            'port: ' + repr(self.port) + ' ' +\
  499            'port_override: ' + repr(self.port_override) + ' ' +\
  500            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  501            'tags: ' + repr(self.tags) + ' ' +\
  502            'token: ' + repr(self.token) + ' ' +\
  503            '>'
  504
  505    def to_dict(self):
  506        return {
  507            'bind_interface': self.bind_interface,
  508            'egress_filter': self.egress_filter,
  509            'healthcheck_namespace': self.healthcheck_namespace,
  510            'healthy': self.healthy,
  511            'hostname': self.hostname,
  512            'id': self.id,
  513            'name': self.name,
  514            'port': self.port,
  515            'port_override': self.port_override,
  516            'secret_store_id': self.secret_store_id,
  517            'tags': self.tags,
  518            'token': self.token,
  519        }
  520
  521    @classmethod
  522    def from_dict(cls, d):
  523        return cls(
  524            bind_interface=d.get('bind_interface'),
  525            egress_filter=d.get('egress_filter'),
  526            healthcheck_namespace=d.get('healthcheck_namespace'),
  527            healthy=d.get('healthy'),
  528            hostname=d.get('hostname'),
  529            id=d.get('id'),
  530            name=d.get('name'),
  531            port=d.get('port'),
  532            port_override=d.get('port_override'),
  533            secret_store_id=d.get('secret_store_id'),
  534            tags=d.get('tags'),
  535            token=d.get('token'),
  536        )
  537
  538
  539class AKSUserImpersonation:
  540    __slots__ = [
  541        'bind_interface',
  542        'certificate_authority',
  543        'client_certificate',
  544        'client_key',
  545        'egress_filter',
  546        'healthcheck_namespace',
  547        'healthy',
  548        'hostname',
  549        'id',
  550        'name',
  551        'port',
  552        'port_override',
  553        'secret_store_id',
  554        'tags',
  555    ]
  556
  557    def __init__(
  558        self,
  559        bind_interface=None,
  560        certificate_authority=None,
  561        client_certificate=None,
  562        client_key=None,
  563        egress_filter=None,
  564        healthcheck_namespace=None,
  565        healthy=None,
  566        hostname=None,
  567        id=None,
  568        name=None,
  569        port=None,
  570        port_override=None,
  571        secret_store_id=None,
  572        tags=None,
  573    ):
  574        self.bind_interface = bind_interface if bind_interface is not None else ''
  575        '''
  576         Bind interface
  577        '''
  578        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  579        self.client_certificate = client_certificate if client_certificate is not None else ''
  580        self.client_key = client_key if client_key is not None else ''
  581        self.egress_filter = egress_filter if egress_filter is not None else ''
  582        '''
  583         A filter applied to the routing logic to pin datasource to nodes.
  584        '''
  585        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  586        '''
  587         The path used to check the health of your connection.  Defaults to `default`.
  588        '''
  589        self.healthy = healthy if healthy is not None else False
  590        '''
  591         True if the datasource is reachable and the credentials are valid.
  592        '''
  593        self.hostname = hostname if hostname is not None else ''
  594        self.id = id if id is not None else ''
  595        '''
  596         Unique identifier of the Resource.
  597        '''
  598        self.name = name if name is not None else ''
  599        '''
  600         Unique human-readable name of the Resource.
  601        '''
  602        self.port = port if port is not None else 0
  603        self.port_override = port_override if port_override is not None else 0
  604        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  605        '''
  606         ID of the secret store containing credentials for this resource, if any.
  607        '''
  608        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  609        '''
  610         Tags is a map of key, value pairs.
  611        '''
  612
  613    def __repr__(self):
  614        return '<sdm.AKSUserImpersonation ' + \
  615            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  616            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  617            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  618            'client_key: ' + repr(self.client_key) + ' ' +\
  619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  620            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  621            'healthy: ' + repr(self.healthy) + ' ' +\
  622            'hostname: ' + repr(self.hostname) + ' ' +\
  623            'id: ' + repr(self.id) + ' ' +\
  624            'name: ' + repr(self.name) + ' ' +\
  625            'port: ' + repr(self.port) + ' ' +\
  626            'port_override: ' + repr(self.port_override) + ' ' +\
  627            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  628            'tags: ' + repr(self.tags) + ' ' +\
  629            '>'
  630
  631    def to_dict(self):
  632        return {
  633            'bind_interface': self.bind_interface,
  634            'certificate_authority': self.certificate_authority,
  635            'client_certificate': self.client_certificate,
  636            'client_key': self.client_key,
  637            'egress_filter': self.egress_filter,
  638            'healthcheck_namespace': self.healthcheck_namespace,
  639            'healthy': self.healthy,
  640            'hostname': self.hostname,
  641            'id': self.id,
  642            'name': self.name,
  643            'port': self.port,
  644            'port_override': self.port_override,
  645            'secret_store_id': self.secret_store_id,
  646            'tags': self.tags,
  647        }
  648
  649    @classmethod
  650    def from_dict(cls, d):
  651        return cls(
  652            bind_interface=d.get('bind_interface'),
  653            certificate_authority=d.get('certificate_authority'),
  654            client_certificate=d.get('client_certificate'),
  655            client_key=d.get('client_key'),
  656            egress_filter=d.get('egress_filter'),
  657            healthcheck_namespace=d.get('healthcheck_namespace'),
  658            healthy=d.get('healthy'),
  659            hostname=d.get('hostname'),
  660            id=d.get('id'),
  661            name=d.get('name'),
  662            port=d.get('port'),
  663            port_override=d.get('port_override'),
  664            secret_store_id=d.get('secret_store_id'),
  665            tags=d.get('tags'),
  666        )
  667
  668
  669class AWS:
  670    __slots__ = [
  671        'access_key',
  672        'bind_interface',
  673        'egress_filter',
  674        'healthcheck_region',
  675        'healthy',
  676        'id',
  677        'name',
  678        'role_arn',
  679        'role_external_id',
  680        'secret_access_key',
  681        'secret_store_id',
  682        'tags',
  683    ]
  684
  685    def __init__(
  686        self,
  687        access_key=None,
  688        bind_interface=None,
  689        egress_filter=None,
  690        healthcheck_region=None,
  691        healthy=None,
  692        id=None,
  693        name=None,
  694        role_arn=None,
  695        role_external_id=None,
  696        secret_access_key=None,
  697        secret_store_id=None,
  698        tags=None,
  699    ):
  700        self.access_key = access_key if access_key is not None else ''
  701        self.bind_interface = bind_interface if bind_interface is not None else ''
  702        '''
  703         Bind interface
  704        '''
  705        self.egress_filter = egress_filter if egress_filter is not None else ''
  706        '''
  707         A filter applied to the routing logic to pin datasource to nodes.
  708        '''
  709        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  710        self.healthy = healthy if healthy is not None else False
  711        '''
  712         True if the datasource is reachable and the credentials are valid.
  713        '''
  714        self.id = id if id is not None else ''
  715        '''
  716         Unique identifier of the Resource.
  717        '''
  718        self.name = name if name is not None else ''
  719        '''
  720         Unique human-readable name of the Resource.
  721        '''
  722        self.role_arn = role_arn if role_arn is not None else ''
  723        self.role_external_id = role_external_id if role_external_id is not None else ''
  724        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  725        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  726        '''
  727         ID of the secret store containing credentials for this resource, if any.
  728        '''
  729        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  730        '''
  731         Tags is a map of key, value pairs.
  732        '''
  733
  734    def __repr__(self):
  735        return '<sdm.AWS ' + \
  736            'access_key: ' + repr(self.access_key) + ' ' +\
  737            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  738            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  739            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  740            'healthy: ' + repr(self.healthy) + ' ' +\
  741            'id: ' + repr(self.id) + ' ' +\
  742            'name: ' + repr(self.name) + ' ' +\
  743            'role_arn: ' + repr(self.role_arn) + ' ' +\
  744            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  745            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  746            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  747            'tags: ' + repr(self.tags) + ' ' +\
  748            '>'
  749
  750    def to_dict(self):
  751        return {
  752            'access_key': self.access_key,
  753            'bind_interface': self.bind_interface,
  754            'egress_filter': self.egress_filter,
  755            'healthcheck_region': self.healthcheck_region,
  756            'healthy': self.healthy,
  757            'id': self.id,
  758            'name': self.name,
  759            'role_arn': self.role_arn,
  760            'role_external_id': self.role_external_id,
  761            'secret_access_key': self.secret_access_key,
  762            'secret_store_id': self.secret_store_id,
  763            'tags': self.tags,
  764        }
  765
  766    @classmethod
  767    def from_dict(cls, d):
  768        return cls(
  769            access_key=d.get('access_key'),
  770            bind_interface=d.get('bind_interface'),
  771            egress_filter=d.get('egress_filter'),
  772            healthcheck_region=d.get('healthcheck_region'),
  773            healthy=d.get('healthy'),
  774            id=d.get('id'),
  775            name=d.get('name'),
  776            role_arn=d.get('role_arn'),
  777            role_external_id=d.get('role_external_id'),
  778            secret_access_key=d.get('secret_access_key'),
  779            secret_store_id=d.get('secret_store_id'),
  780            tags=d.get('tags'),
  781        )
  782
  783
  784class AWSStore:
  785    __slots__ = [
  786        'id',
  787        'name',
  788        'region',
  789        'tags',
  790    ]
  791
  792    def __init__(
  793        self,
  794        id=None,
  795        name=None,
  796        region=None,
  797        tags=None,
  798    ):
  799        self.id = id if id is not None else ''
  800        '''
  801         Unique identifier of the SecretStore.
  802        '''
  803        self.name = name if name is not None else ''
  804        '''
  805         Unique human-readable name of the SecretStore.
  806        '''
  807        self.region = region if region is not None else ''
  808        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  809        '''
  810         Tags is a map of key, value pairs.
  811        '''
  812
  813    def __repr__(self):
  814        return '<sdm.AWSStore ' + \
  815            'id: ' + repr(self.id) + ' ' +\
  816            'name: ' + repr(self.name) + ' ' +\
  817            'region: ' + repr(self.region) + ' ' +\
  818            'tags: ' + repr(self.tags) + ' ' +\
  819            '>'
  820
  821    def to_dict(self):
  822        return {
  823            'id': self.id,
  824            'name': self.name,
  825            'region': self.region,
  826            'tags': self.tags,
  827        }
  828
  829    @classmethod
  830    def from_dict(cls, d):
  831        return cls(
  832            id=d.get('id'),
  833            name=d.get('name'),
  834            region=d.get('region'),
  835            tags=d.get('tags'),
  836        )
  837
  838
  839class AccountAttachment:
  840    '''
  841         AccountAttachments assign an account to a role.
  842    '''
  843    __slots__ = [
  844        'account_id',
  845        'id',
  846        'role_id',
  847    ]
  848
  849    def __init__(
  850        self,
  851        account_id=None,
  852        id=None,
  853        role_id=None,
  854    ):
  855        self.account_id = account_id if account_id is not None else ''
  856        '''
  857         The id of the account of this AccountAttachment.
  858        '''
  859        self.id = id if id is not None else ''
  860        '''
  861         Unique identifier of the AccountAttachment.
  862        '''
  863        self.role_id = role_id if role_id is not None else ''
  864        '''
  865         The id of the attached role of this AccountAttachment.
  866        '''
  867
  868    def __repr__(self):
  869        return '<sdm.AccountAttachment ' + \
  870            'account_id: ' + repr(self.account_id) + ' ' +\
  871            'id: ' + repr(self.id) + ' ' +\
  872            'role_id: ' + repr(self.role_id) + ' ' +\
  873            '>'
  874
  875    def to_dict(self):
  876        return {
  877            'account_id': self.account_id,
  878            'id': self.id,
  879            'role_id': self.role_id,
  880        }
  881
  882    @classmethod
  883    def from_dict(cls, d):
  884        return cls(
  885            account_id=d.get('account_id'),
  886            id=d.get('id'),
  887            role_id=d.get('role_id'),
  888        )
  889
  890
  891class AccountAttachmentCreateResponse:
  892    '''
  893         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
  894    '''
  895    __slots__ = [
  896        'account_attachment',
  897        'meta',
  898        'rate_limit',
  899    ]
  900
  901    def __init__(
  902        self,
  903        account_attachment=None,
  904        meta=None,
  905        rate_limit=None,
  906    ):
  907        self.account_attachment = account_attachment if account_attachment is not None else None
  908        '''
  909         The created AccountAttachment.
  910        '''
  911        self.meta = meta if meta is not None else None
  912        '''
  913         Reserved for future use.
  914        '''
  915        self.rate_limit = rate_limit if rate_limit is not None else None
  916        '''
  917         Rate limit information.
  918        '''
  919
  920    def __repr__(self):
  921        return '<sdm.AccountAttachmentCreateResponse ' + \
  922            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
  923            'meta: ' + repr(self.meta) + ' ' +\
  924            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
  925            '>'
  926
  927    def to_dict(self):
  928        return {
  929            'account_attachment': self.account_attachment,
  930            'meta': self.meta,
  931            'rate_limit': self.rate_limit,
  932        }
  933
  934    @classmethod
  935    def from_dict(cls, d):
  936        return cls(
  937            account_attachment=d.get('account_attachment'),
  938            meta=d.get('meta'),
  939            rate_limit=d.get('rate_limit'),
  940        )
  941
  942
  943class AccountAttachmentDeleteResponse:
  944    '''
  945         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
  946    '''
  947    __slots__ = [
  948        'meta',
  949        'rate_limit',
  950    ]
  951
  952    def __init__(
  953        self,
  954        meta=None,
  955        rate_limit=None,
  956    ):
  957        self.meta = meta if meta is not None else None
  958        '''
  959         Reserved for future use.
  960        '''
  961        self.rate_limit = rate_limit if rate_limit is not None else None
  962        '''
  963         Rate limit information.
  964        '''
  965
  966    def __repr__(self):
  967        return '<sdm.AccountAttachmentDeleteResponse ' + \
  968            'meta: ' + repr(self.meta) + ' ' +\
  969            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
  970            '>'
  971
  972    def to_dict(self):
  973        return {
  974            'meta': self.meta,
  975            'rate_limit': self.rate_limit,
  976        }
  977
  978    @classmethod
  979    def from_dict(cls, d):
  980        return cls(
  981            meta=d.get('meta'),
  982            rate_limit=d.get('rate_limit'),
  983        )
  984
  985
  986class AccountAttachmentGetResponse:
  987    '''
  988         AccountAttachmentGetResponse returns a requested AccountAttachment.
  989    '''
  990    __slots__ = [
  991        'account_attachment',
  992        'meta',
  993        'rate_limit',
  994    ]
  995
  996    def __init__(
  997        self,
  998        account_attachment=None,
  999        meta=None,
 1000        rate_limit=None,
 1001    ):
 1002        self.account_attachment = account_attachment if account_attachment is not None else None
 1003        '''
 1004         The requested AccountAttachment.
 1005        '''
 1006        self.meta = meta if meta is not None else None
 1007        '''
 1008         Reserved for future use.
 1009        '''
 1010        self.rate_limit = rate_limit if rate_limit is not None else None
 1011        '''
 1012         Rate limit information.
 1013        '''
 1014
 1015    def __repr__(self):
 1016        return '<sdm.AccountAttachmentGetResponse ' + \
 1017            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1018            'meta: ' + repr(self.meta) + ' ' +\
 1019            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1020            '>'
 1021
 1022    def to_dict(self):
 1023        return {
 1024            'account_attachment': self.account_attachment,
 1025            'meta': self.meta,
 1026            'rate_limit': self.rate_limit,
 1027        }
 1028
 1029    @classmethod
 1030    def from_dict(cls, d):
 1031        return cls(
 1032            account_attachment=d.get('account_attachment'),
 1033            meta=d.get('meta'),
 1034            rate_limit=d.get('rate_limit'),
 1035        )
 1036
 1037
 1038class AccountCreateResponse:
 1039    '''
 1040         AccountCreateResponse reports how the Accounts were created in the system.
 1041    '''
 1042    __slots__ = [
 1043        'account',
 1044        'meta',
 1045        'rate_limit',
 1046        'token',
 1047    ]
 1048
 1049    def __init__(
 1050        self,
 1051        account=None,
 1052        meta=None,
 1053        rate_limit=None,
 1054        token=None,
 1055    ):
 1056        self.account = account if account is not None else None
 1057        '''
 1058         The created Account.
 1059        '''
 1060        self.meta = meta if meta is not None else None
 1061        '''
 1062         Reserved for future use.
 1063        '''
 1064        self.rate_limit = rate_limit if rate_limit is not None else None
 1065        '''
 1066         Rate limit information.
 1067        '''
 1068        self.token = token if token is not None else ''
 1069        '''
 1070         The auth token generated for the Account. The Account will use this token to
 1071         authenticate with the strongDM API.
 1072        '''
 1073
 1074    def __repr__(self):
 1075        return '<sdm.AccountCreateResponse ' + \
 1076            'account: ' + repr(self.account) + ' ' +\
 1077            'meta: ' + repr(self.meta) + ' ' +\
 1078            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1079            'token: ' + repr(self.token) + ' ' +\
 1080            '>'
 1081
 1082    def to_dict(self):
 1083        return {
 1084            'account': self.account,
 1085            'meta': self.meta,
 1086            'rate_limit': self.rate_limit,
 1087            'token': self.token,
 1088        }
 1089
 1090    @classmethod
 1091    def from_dict(cls, d):
 1092        return cls(
 1093            account=d.get('account'),
 1094            meta=d.get('meta'),
 1095            rate_limit=d.get('rate_limit'),
 1096            token=d.get('token'),
 1097        )
 1098
 1099
 1100class AccountDeleteResponse:
 1101    '''
 1102         AccountDeleteResponse returns information about a Account that was deleted.
 1103    '''
 1104    __slots__ = [
 1105        'meta',
 1106        'rate_limit',
 1107    ]
 1108
 1109    def __init__(
 1110        self,
 1111        meta=None,
 1112        rate_limit=None,
 1113    ):
 1114        self.meta = meta if meta is not None else None
 1115        '''
 1116         Reserved for future use.
 1117        '''
 1118        self.rate_limit = rate_limit if rate_limit is not None else None
 1119        '''
 1120         Rate limit information.
 1121        '''
 1122
 1123    def __repr__(self):
 1124        return '<sdm.AccountDeleteResponse ' + \
 1125            'meta: ' + repr(self.meta) + ' ' +\
 1126            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1127            '>'
 1128
 1129    def to_dict(self):
 1130        return {
 1131            'meta': self.meta,
 1132            'rate_limit': self.rate_limit,
 1133        }
 1134
 1135    @classmethod
 1136    def from_dict(cls, d):
 1137        return cls(
 1138            meta=d.get('meta'),
 1139            rate_limit=d.get('rate_limit'),
 1140        )
 1141
 1142
 1143class AccountGetResponse:
 1144    '''
 1145         AccountGetResponse returns a requested Account.
 1146    '''
 1147    __slots__ = [
 1148        'account',
 1149        'meta',
 1150        'rate_limit',
 1151    ]
 1152
 1153    def __init__(
 1154        self,
 1155        account=None,
 1156        meta=None,
 1157        rate_limit=None,
 1158    ):
 1159        self.account = account if account is not None else None
 1160        '''
 1161         The requested Account.
 1162        '''
 1163        self.meta = meta if meta is not None else None
 1164        '''
 1165         Reserved for future use.
 1166        '''
 1167        self.rate_limit = rate_limit if rate_limit is not None else None
 1168        '''
 1169         Rate limit information.
 1170        '''
 1171
 1172    def __repr__(self):
 1173        return '<sdm.AccountGetResponse ' + \
 1174            'account: ' + repr(self.account) + ' ' +\
 1175            'meta: ' + repr(self.meta) + ' ' +\
 1176            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1177            '>'
 1178
 1179    def to_dict(self):
 1180        return {
 1181            'account': self.account,
 1182            'meta': self.meta,
 1183            'rate_limit': self.rate_limit,
 1184        }
 1185
 1186    @classmethod
 1187    def from_dict(cls, d):
 1188        return cls(
 1189            account=d.get('account'),
 1190            meta=d.get('meta'),
 1191            rate_limit=d.get('rate_limit'),
 1192        )
 1193
 1194
 1195class AccountGrant:
 1196    '''
 1197         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1198    '''
 1199    __slots__ = [
 1200        'account_id',
 1201        'id',
 1202        'resource_id',
 1203        'start_from',
 1204        'valid_until',
 1205    ]
 1206
 1207    def __init__(
 1208        self,
 1209        account_id=None,
 1210        id=None,
 1211        resource_id=None,
 1212        start_from=None,
 1213        valid_until=None,
 1214    ):
 1215        self.account_id = account_id if account_id is not None else ''
 1216        '''
 1217         The account ID of this AccountGrant.
 1218        '''
 1219        self.id = id if id is not None else ''
 1220        '''
 1221         Unique identifier of the AccountGrant.
 1222        '''
 1223        self.resource_id = resource_id if resource_id is not None else ''
 1224        '''
 1225         The resource ID of this AccountGrant.
 1226        '''
 1227        self.start_from = start_from if start_from is not None else None
 1228        '''
 1229         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
 1230        '''
 1231        self.valid_until = valid_until if valid_until is not None else None
 1232        '''
 1233         The timestamp when the resource grant will expire.
 1234        '''
 1235
 1236    def __repr__(self):
 1237        return '<sdm.AccountGrant ' + \
 1238            'account_id: ' + repr(self.account_id) + ' ' +\
 1239            'id: ' + repr(self.id) + ' ' +\
 1240            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1241            'start_from: ' + repr(self.start_from) + ' ' +\
 1242            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1243            '>'
 1244
 1245    def to_dict(self):
 1246        return {
 1247            'account_id': self.account_id,
 1248            'id': self.id,
 1249            'resource_id': self.resource_id,
 1250            'start_from': self.start_from,
 1251            'valid_until': self.valid_until,
 1252        }
 1253
 1254    @classmethod
 1255    def from_dict(cls, d):
 1256        return cls(
 1257            account_id=d.get('account_id'),
 1258            id=d.get('id'),
 1259            resource_id=d.get('resource_id'),
 1260            start_from=d.get('start_from'),
 1261            valid_until=d.get('valid_until'),
 1262        )
 1263
 1264
 1265class AccountGrantCreateResponse:
 1266    '''
 1267         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1268    '''
 1269    __slots__ = [
 1270        'account_grant',
 1271        'meta',
 1272        'rate_limit',
 1273    ]
 1274
 1275    def __init__(
 1276        self,
 1277        account_grant=None,
 1278        meta=None,
 1279        rate_limit=None,
 1280    ):
 1281        self.account_grant = account_grant if account_grant is not None else None
 1282        '''
 1283         The created AccountGrant.
 1284        '''
 1285        self.meta = meta if meta is not None else None
 1286        '''
 1287         Reserved for future use.
 1288        '''
 1289        self.rate_limit = rate_limit if rate_limit is not None else None
 1290        '''
 1291         Rate limit information.
 1292        '''
 1293
 1294    def __repr__(self):
 1295        return '<sdm.AccountGrantCreateResponse ' + \
 1296            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1297            'meta: ' + repr(self.meta) + ' ' +\
 1298            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1299            '>'
 1300
 1301    def to_dict(self):
 1302        return {
 1303            'account_grant': self.account_grant,
 1304            'meta': self.meta,
 1305            'rate_limit': self.rate_limit,
 1306        }
 1307
 1308    @classmethod
 1309    def from_dict(cls, d):
 1310        return cls(
 1311            account_grant=d.get('account_grant'),
 1312            meta=d.get('meta'),
 1313            rate_limit=d.get('rate_limit'),
 1314        )
 1315
 1316
 1317class AccountGrantDeleteResponse:
 1318    '''
 1319         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1320    '''
 1321    __slots__ = [
 1322        'meta',
 1323        'rate_limit',
 1324    ]
 1325
 1326    def __init__(
 1327        self,
 1328        meta=None,
 1329        rate_limit=None,
 1330    ):
 1331        self.meta = meta if meta is not None else None
 1332        '''
 1333         Reserved for future use.
 1334        '''
 1335        self.rate_limit = rate_limit if rate_limit is not None else None
 1336        '''
 1337         Rate limit information.
 1338        '''
 1339
 1340    def __repr__(self):
 1341        return '<sdm.AccountGrantDeleteResponse ' + \
 1342            'meta: ' + repr(self.meta) + ' ' +\
 1343            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1344            '>'
 1345
 1346    def to_dict(self):
 1347        return {
 1348            'meta': self.meta,
 1349            'rate_limit': self.rate_limit,
 1350        }
 1351
 1352    @classmethod
 1353    def from_dict(cls, d):
 1354        return cls(
 1355            meta=d.get('meta'),
 1356            rate_limit=d.get('rate_limit'),
 1357        )
 1358
 1359
 1360class AccountGrantGetResponse:
 1361    '''
 1362         AccountGrantGetResponse returns a requested AccountGrant.
 1363    '''
 1364    __slots__ = [
 1365        'account_grant',
 1366        'meta',
 1367        'rate_limit',
 1368    ]
 1369
 1370    def __init__(
 1371        self,
 1372        account_grant=None,
 1373        meta=None,
 1374        rate_limit=None,
 1375    ):
 1376        self.account_grant = account_grant if account_grant is not None else None
 1377        '''
 1378         The requested AccountGrant.
 1379        '''
 1380        self.meta = meta if meta is not None else None
 1381        '''
 1382         Reserved for future use.
 1383        '''
 1384        self.rate_limit = rate_limit if rate_limit is not None else None
 1385        '''
 1386         Rate limit information.
 1387        '''
 1388
 1389    def __repr__(self):
 1390        return '<sdm.AccountGrantGetResponse ' + \
 1391            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1392            'meta: ' + repr(self.meta) + ' ' +\
 1393            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1394            '>'
 1395
 1396    def to_dict(self):
 1397        return {
 1398            'account_grant': self.account_grant,
 1399            'meta': self.meta,
 1400            'rate_limit': self.rate_limit,
 1401        }
 1402
 1403    @classmethod
 1404    def from_dict(cls, d):
 1405        return cls(
 1406            account_grant=d.get('account_grant'),
 1407            meta=d.get('meta'),
 1408            rate_limit=d.get('rate_limit'),
 1409        )
 1410
 1411
 1412class AccountUpdateResponse:
 1413    '''
 1414         AccountUpdateResponse returns the fields of a Account after it has been updated by
 1415     a AccountUpdateRequest.
 1416    '''
 1417    __slots__ = [
 1418        'account',
 1419        'meta',
 1420        'rate_limit',
 1421    ]
 1422
 1423    def __init__(
 1424        self,
 1425        account=None,
 1426        meta=None,
 1427        rate_limit=None,
 1428    ):
 1429        self.account = account if account is not None else None
 1430        '''
 1431         The updated Account.
 1432        '''
 1433        self.meta = meta if meta is not None else None
 1434        '''
 1435         Reserved for future use.
 1436        '''
 1437        self.rate_limit = rate_limit if rate_limit is not None else None
 1438        '''
 1439         Rate limit information.
 1440        '''
 1441
 1442    def __repr__(self):
 1443        return '<sdm.AccountUpdateResponse ' + \
 1444            'account: ' + repr(self.account) + ' ' +\
 1445            'meta: ' + repr(self.meta) + ' ' +\
 1446            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1447            '>'
 1448
 1449    def to_dict(self):
 1450        return {
 1451            'account': self.account,
 1452            'meta': self.meta,
 1453            'rate_limit': self.rate_limit,
 1454        }
 1455
 1456    @classmethod
 1457    def from_dict(cls, d):
 1458        return cls(
 1459            account=d.get('account'),
 1460            meta=d.get('meta'),
 1461            rate_limit=d.get('rate_limit'),
 1462        )
 1463
 1464
 1465class AmazonEKS:
 1466    __slots__ = [
 1467        'access_key',
 1468        'bind_interface',
 1469        'certificate_authority',
 1470        'cluster_name',
 1471        'egress_filter',
 1472        'endpoint',
 1473        'healthcheck_namespace',
 1474        'healthy',
 1475        'id',
 1476        'name',
 1477        'region',
 1478        'remote_identity_group_id',
 1479        'remote_identity_healthcheck_username',
 1480        'role_arn',
 1481        'role_external_id',
 1482        'secret_access_key',
 1483        'secret_store_id',
 1484        'tags',
 1485    ]
 1486
 1487    def __init__(
 1488        self,
 1489        access_key=None,
 1490        bind_interface=None,
 1491        certificate_authority=None,
 1492        cluster_name=None,
 1493        egress_filter=None,
 1494        endpoint=None,
 1495        healthcheck_namespace=None,
 1496        healthy=None,
 1497        id=None,
 1498        name=None,
 1499        region=None,
 1500        remote_identity_group_id=None,
 1501        remote_identity_healthcheck_username=None,
 1502        role_arn=None,
 1503        role_external_id=None,
 1504        secret_access_key=None,
 1505        secret_store_id=None,
 1506        tags=None,
 1507    ):
 1508        self.access_key = access_key if access_key is not None else ''
 1509        self.bind_interface = bind_interface if bind_interface is not None else ''
 1510        '''
 1511         Bind interface
 1512        '''
 1513        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1514        self.cluster_name = cluster_name if cluster_name is not None else ''
 1515        self.egress_filter = egress_filter if egress_filter is not None else ''
 1516        '''
 1517         A filter applied to the routing logic to pin datasource to nodes.
 1518        '''
 1519        self.endpoint = endpoint if endpoint is not None else ''
 1520        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1521        '''
 1522         The path used to check the health of your connection.  Defaults to `default`.
 1523        '''
 1524        self.healthy = healthy if healthy is not None else False
 1525        '''
 1526         True if the datasource is reachable and the credentials are valid.
 1527        '''
 1528        self.id = id if id is not None else ''
 1529        '''
 1530         Unique identifier of the Resource.
 1531        '''
 1532        self.name = name if name is not None else ''
 1533        '''
 1534         Unique human-readable name of the Resource.
 1535        '''
 1536        self.region = region if region is not None else ''
 1537        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1538        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1539        self.role_arn = role_arn if role_arn is not None else ''
 1540        self.role_external_id = role_external_id if role_external_id is not None else ''
 1541        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1542        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1543        '''
 1544         ID of the secret store containing credentials for this resource, if any.
 1545        '''
 1546        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1547        '''
 1548         Tags is a map of key, value pairs.
 1549        '''
 1550
 1551    def __repr__(self):
 1552        return '<sdm.AmazonEKS ' + \
 1553            'access_key: ' + repr(self.access_key) + ' ' +\
 1554            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1555            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1556            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1557            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1558            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1559            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1560            'healthy: ' + repr(self.healthy) + ' ' +\
 1561            'id: ' + repr(self.id) + ' ' +\
 1562            'name: ' + repr(self.name) + ' ' +\
 1563            'region: ' + repr(self.region) + ' ' +\
 1564            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1565            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1566            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1567            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1568            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1569            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1570            'tags: ' + repr(self.tags) + ' ' +\
 1571            '>'
 1572
 1573    def to_dict(self):
 1574        return {
 1575            'access_key': self.access_key,
 1576            'bind_interface': self.bind_interface,
 1577            'certificate_authority': self.certificate_authority,
 1578            'cluster_name': self.cluster_name,
 1579            'egress_filter': self.egress_filter,
 1580            'endpoint': self.endpoint,
 1581            'healthcheck_namespace': self.healthcheck_namespace,
 1582            'healthy': self.healthy,
 1583            'id': self.id,
 1584            'name': self.name,
 1585            'region': self.region,
 1586            'remote_identity_group_id': self.remote_identity_group_id,
 1587            'remote_identity_healthcheck_username':
 1588            self.remote_identity_healthcheck_username,
 1589            'role_arn': self.role_arn,
 1590            'role_external_id': self.role_external_id,
 1591            'secret_access_key': self.secret_access_key,
 1592            'secret_store_id': self.secret_store_id,
 1593            'tags': self.tags,
 1594        }
 1595
 1596    @classmethod
 1597    def from_dict(cls, d):
 1598        return cls(
 1599            access_key=d.get('access_key'),
 1600            bind_interface=d.get('bind_interface'),
 1601            certificate_authority=d.get('certificate_authority'),
 1602            cluster_name=d.get('cluster_name'),
 1603            egress_filter=d.get('egress_filter'),
 1604            endpoint=d.get('endpoint'),
 1605            healthcheck_namespace=d.get('healthcheck_namespace'),
 1606            healthy=d.get('healthy'),
 1607            id=d.get('id'),
 1608            name=d.get('name'),
 1609            region=d.get('region'),
 1610            remote_identity_group_id=d.get('remote_identity_group_id'),
 1611            remote_identity_healthcheck_username=d.get(
 1612                'remote_identity_healthcheck_username'),
 1613            role_arn=d.get('role_arn'),
 1614            role_external_id=d.get('role_external_id'),
 1615            secret_access_key=d.get('secret_access_key'),
 1616            secret_store_id=d.get('secret_store_id'),
 1617            tags=d.get('tags'),
 1618        )
 1619
 1620
 1621class AmazonEKSUserImpersonation:
 1622    __slots__ = [
 1623        'access_key',
 1624        'bind_interface',
 1625        'certificate_authority',
 1626        'cluster_name',
 1627        'egress_filter',
 1628        'endpoint',
 1629        'healthcheck_namespace',
 1630        'healthy',
 1631        'id',
 1632        'name',
 1633        'region',
 1634        'role_arn',
 1635        'role_external_id',
 1636        'secret_access_key',
 1637        'secret_store_id',
 1638        'tags',
 1639    ]
 1640
 1641    def __init__(
 1642        self,
 1643        access_key=None,
 1644        bind_interface=None,
 1645        certificate_authority=None,
 1646        cluster_name=None,
 1647        egress_filter=None,
 1648        endpoint=None,
 1649        healthcheck_namespace=None,
 1650        healthy=None,
 1651        id=None,
 1652        name=None,
 1653        region=None,
 1654        role_arn=None,
 1655        role_external_id=None,
 1656        secret_access_key=None,
 1657        secret_store_id=None,
 1658        tags=None,
 1659    ):
 1660        self.access_key = access_key if access_key is not None else ''
 1661        self.bind_interface = bind_interface if bind_interface is not None else ''
 1662        '''
 1663         Bind interface
 1664        '''
 1665        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1666        self.cluster_name = cluster_name if cluster_name is not None else ''
 1667        self.egress_filter = egress_filter if egress_filter is not None else ''
 1668        '''
 1669         A filter applied to the routing logic to pin datasource to nodes.
 1670        '''
 1671        self.endpoint = endpoint if endpoint is not None else ''
 1672        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1673        '''
 1674         The path used to check the health of your connection.  Defaults to `default`.
 1675        '''
 1676        self.healthy = healthy if healthy is not None else False
 1677        '''
 1678         True if the datasource is reachable and the credentials are valid.
 1679        '''
 1680        self.id = id if id is not None else ''
 1681        '''
 1682         Unique identifier of the Resource.
 1683        '''
 1684        self.name = name if name is not None else ''
 1685        '''
 1686         Unique human-readable name of the Resource.
 1687        '''
 1688        self.region = region if region is not None else ''
 1689        self.role_arn = role_arn if role_arn is not None else ''
 1690        self.role_external_id = role_external_id if role_external_id is not None else ''
 1691        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1692        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1693        '''
 1694         ID of the secret store containing credentials for this resource, if any.
 1695        '''
 1696        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1697        '''
 1698         Tags is a map of key, value pairs.
 1699        '''
 1700
 1701    def __repr__(self):
 1702        return '<sdm.AmazonEKSUserImpersonation ' + \
 1703            'access_key: ' + repr(self.access_key) + ' ' +\
 1704            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1705            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1706            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1707            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1708            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1709            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1710            'healthy: ' + repr(self.healthy) + ' ' +\
 1711            'id: ' + repr(self.id) + ' ' +\
 1712            'name: ' + repr(self.name) + ' ' +\
 1713            'region: ' + repr(self.region) + ' ' +\
 1714            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1715            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1716            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1717            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1718            'tags: ' + repr(self.tags) + ' ' +\
 1719            '>'
 1720
 1721    def to_dict(self):
 1722        return {
 1723            'access_key': self.access_key,
 1724            'bind_interface': self.bind_interface,
 1725            'certificate_authority': self.certificate_authority,
 1726            'cluster_name': self.cluster_name,
 1727            'egress_filter': self.egress_filter,
 1728            'endpoint': self.endpoint,
 1729            'healthcheck_namespace': self.healthcheck_namespace,
 1730            'healthy': self.healthy,
 1731            'id': self.id,
 1732            'name': self.name,
 1733            'region': self.region,
 1734            'role_arn': self.role_arn,
 1735            'role_external_id': self.role_external_id,
 1736            'secret_access_key': self.secret_access_key,
 1737            'secret_store_id': self.secret_store_id,
 1738            'tags': self.tags,
 1739        }
 1740
 1741    @classmethod
 1742    def from_dict(cls, d):
 1743        return cls(
 1744            access_key=d.get('access_key'),
 1745            bind_interface=d.get('bind_interface'),
 1746            certificate_authority=d.get('certificate_authority'),
 1747            cluster_name=d.get('cluster_name'),
 1748            egress_filter=d.get('egress_filter'),
 1749            endpoint=d.get('endpoint'),
 1750            healthcheck_namespace=d.get('healthcheck_namespace'),
 1751            healthy=d.get('healthy'),
 1752            id=d.get('id'),
 1753            name=d.get('name'),
 1754            region=d.get('region'),
 1755            role_arn=d.get('role_arn'),
 1756            role_external_id=d.get('role_external_id'),
 1757            secret_access_key=d.get('secret_access_key'),
 1758            secret_store_id=d.get('secret_store_id'),
 1759            tags=d.get('tags'),
 1760        )
 1761
 1762
 1763class AmazonES:
 1764    __slots__ = [
 1765        'access_key',
 1766        'bind_interface',
 1767        'egress_filter',
 1768        'endpoint',
 1769        'healthy',
 1770        'id',
 1771        'name',
 1772        'port_override',
 1773        'region',
 1774        'role_arn',
 1775        'role_external_id',
 1776        'secret_access_key',
 1777        'secret_store_id',
 1778        'tags',
 1779    ]
 1780
 1781    def __init__(
 1782        self,
 1783        access_key=None,
 1784        bind_interface=None,
 1785        egress_filter=None,
 1786        endpoint=None,
 1787        healthy=None,
 1788        id=None,
 1789        name=None,
 1790        port_override=None,
 1791        region=None,
 1792        role_arn=None,
 1793        role_external_id=None,
 1794        secret_access_key=None,
 1795        secret_store_id=None,
 1796        tags=None,
 1797    ):
 1798        self.access_key = access_key if access_key is not None else ''
 1799        self.bind_interface = bind_interface if bind_interface is not None else ''
 1800        '''
 1801         Bind interface
 1802        '''
 1803        self.egress_filter = egress_filter if egress_filter is not None else ''
 1804        '''
 1805         A filter applied to the routing logic to pin datasource to nodes.
 1806        '''
 1807        self.endpoint = endpoint if endpoint is not None else ''
 1808        self.healthy = healthy if healthy is not None else False
 1809        '''
 1810         True if the datasource is reachable and the credentials are valid.
 1811        '''
 1812        self.id = id if id is not None else ''
 1813        '''
 1814         Unique identifier of the Resource.
 1815        '''
 1816        self.name = name if name is not None else ''
 1817        '''
 1818         Unique human-readable name of the Resource.
 1819        '''
 1820        self.port_override = port_override if port_override is not None else 0
 1821        self.region = region if region is not None else ''
 1822        self.role_arn = role_arn if role_arn is not None else ''
 1823        self.role_external_id = role_external_id if role_external_id is not None else ''
 1824        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1825        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1826        '''
 1827         ID of the secret store containing credentials for this resource, if any.
 1828        '''
 1829        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1830        '''
 1831         Tags is a map of key, value pairs.
 1832        '''
 1833
 1834    def __repr__(self):
 1835        return '<sdm.AmazonES ' + \
 1836            'access_key: ' + repr(self.access_key) + ' ' +\
 1837            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1838            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1839            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1840            'healthy: ' + repr(self.healthy) + ' ' +\
 1841            'id: ' + repr(self.id) + ' ' +\
 1842            'name: ' + repr(self.name) + ' ' +\
 1843            'port_override: ' + repr(self.port_override) + ' ' +\
 1844            'region: ' + repr(self.region) + ' ' +\
 1845            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1846            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1847            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1848            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1849            'tags: ' + repr(self.tags) + ' ' +\
 1850            '>'
 1851
 1852    def to_dict(self):
 1853        return {
 1854            'access_key': self.access_key,
 1855            'bind_interface': self.bind_interface,
 1856            'egress_filter': self.egress_filter,
 1857            'endpoint': self.endpoint,
 1858            'healthy': self.healthy,
 1859            'id': self.id,
 1860            'name': self.name,
 1861            'port_override': self.port_override,
 1862            'region': self.region,
 1863            'role_arn': self.role_arn,
 1864            'role_external_id': self.role_external_id,
 1865            'secret_access_key': self.secret_access_key,
 1866            'secret_store_id': self.secret_store_id,
 1867            'tags': self.tags,
 1868        }
 1869
 1870    @classmethod
 1871    def from_dict(cls, d):
 1872        return cls(
 1873            access_key=d.get('access_key'),
 1874            bind_interface=d.get('bind_interface'),
 1875            egress_filter=d.get('egress_filter'),
 1876            endpoint=d.get('endpoint'),
 1877            healthy=d.get('healthy'),
 1878            id=d.get('id'),
 1879            name=d.get('name'),
 1880            port_override=d.get('port_override'),
 1881            region=d.get('region'),
 1882            role_arn=d.get('role_arn'),
 1883            role_external_id=d.get('role_external_id'),
 1884            secret_access_key=d.get('secret_access_key'),
 1885            secret_store_id=d.get('secret_store_id'),
 1886            tags=d.get('tags'),
 1887        )
 1888
 1889
 1890class AmazonMQAMQP091:
 1891    __slots__ = [
 1892        'bind_interface',
 1893        'egress_filter',
 1894        'healthy',
 1895        'hostname',
 1896        'id',
 1897        'name',
 1898        'password',
 1899        'port',
 1900        'port_override',
 1901        'secret_store_id',
 1902        'tags',
 1903        'tls_required',
 1904        'username',
 1905    ]
 1906
 1907    def __init__(
 1908        self,
 1909        bind_interface=None,
 1910        egress_filter=None,
 1911        healthy=None,
 1912        hostname=None,
 1913        id=None,
 1914        name=None,
 1915        password=None,
 1916        port=None,
 1917        port_override=None,
 1918        secret_store_id=None,
 1919        tags=None,
 1920        tls_required=None,
 1921        username=None,
 1922    ):
 1923        self.bind_interface = bind_interface if bind_interface is not None else ''
 1924        '''
 1925         Bind interface
 1926        '''
 1927        self.egress_filter = egress_filter if egress_filter is not None else ''
 1928        '''
 1929         A filter applied to the routing logic to pin datasource to nodes.
 1930        '''
 1931        self.healthy = healthy if healthy is not None else False
 1932        '''
 1933         True if the datasource is reachable and the credentials are valid.
 1934        '''
 1935        self.hostname = hostname if hostname is not None else ''
 1936        self.id = id if id is not None else ''
 1937        '''
 1938         Unique identifier of the Resource.
 1939        '''
 1940        self.name = name if name is not None else ''
 1941        '''
 1942         Unique human-readable name of the Resource.
 1943        '''
 1944        self.password = password if password is not None else ''
 1945        self.port = port if port is not None else 0
 1946        self.port_override = port_override if port_override is not None else 0
 1947        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1948        '''
 1949         ID of the secret store containing credentials for this resource, if any.
 1950        '''
 1951        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1952        '''
 1953         Tags is a map of key, value pairs.
 1954        '''
 1955        self.tls_required = tls_required if tls_required is not None else False
 1956        self.username = username if username is not None else ''
 1957
 1958    def __repr__(self):
 1959        return '<sdm.AmazonMQAMQP091 ' + \
 1960            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1961            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1962            'healthy: ' + repr(self.healthy) + ' ' +\
 1963            'hostname: ' + repr(self.hostname) + ' ' +\
 1964            'id: ' + repr(self.id) + ' ' +\
 1965            'name: ' + repr(self.name) + ' ' +\
 1966            'password: ' + repr(self.password) + ' ' +\
 1967            'port: ' + repr(self.port) + ' ' +\
 1968            'port_override: ' + repr(self.port_override) + ' ' +\
 1969            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1970            'tags: ' + repr(self.tags) + ' ' +\
 1971            'tls_required: ' + repr(self.tls_required) + ' ' +\
 1972            'username: ' + repr(self.username) + ' ' +\
 1973            '>'
 1974
 1975    def to_dict(self):
 1976        return {
 1977            'bind_interface': self.bind_interface,
 1978            'egress_filter': self.egress_filter,
 1979            'healthy': self.healthy,
 1980            'hostname': self.hostname,
 1981            'id': self.id,
 1982            'name': self.name,
 1983            'password': self.password,
 1984            'port': self.port,
 1985            'port_override': self.port_override,
 1986            'secret_store_id': self.secret_store_id,
 1987            'tags': self.tags,
 1988            'tls_required': self.tls_required,
 1989            'username': self.username,
 1990        }
 1991
 1992    @classmethod
 1993    def from_dict(cls, d):
 1994        return cls(
 1995            bind_interface=d.get('bind_interface'),
 1996            egress_filter=d.get('egress_filter'),
 1997            healthy=d.get('healthy'),
 1998            hostname=d.get('hostname'),
 1999            id=d.get('id'),
 2000            name=d.get('name'),
 2001            password=d.get('password'),
 2002            port=d.get('port'),
 2003            port_override=d.get('port_override'),
 2004            secret_store_id=d.get('secret_store_id'),
 2005            tags=d.get('tags'),
 2006            tls_required=d.get('tls_required'),
 2007            username=d.get('username'),
 2008        )
 2009
 2010
 2011class Athena:
 2012    __slots__ = [
 2013        'access_key',
 2014        'bind_interface',
 2015        'egress_filter',
 2016        'healthy',
 2017        'id',
 2018        'name',
 2019        'output',
 2020        'port_override',
 2021        'region',
 2022        'role_arn',
 2023        'role_external_id',
 2024        'secret_access_key',
 2025        'secret_store_id',
 2026        'tags',
 2027    ]
 2028
 2029    def __init__(
 2030        self,
 2031        access_key=None,
 2032        bind_interface=None,
 2033        egress_filter=None,
 2034        healthy=None,
 2035        id=None,
 2036        name=None,
 2037        output=None,
 2038        port_override=None,
 2039        region=None,
 2040        role_arn=None,
 2041        role_external_id=None,
 2042        secret_access_key=None,
 2043        secret_store_id=None,
 2044        tags=None,
 2045    ):
 2046        self.access_key = access_key if access_key is not None else ''
 2047        self.bind_interface = bind_interface if bind_interface is not None else ''
 2048        '''
 2049         Bind interface
 2050        '''
 2051        self.egress_filter = egress_filter if egress_filter is not None else ''
 2052        '''
 2053         A filter applied to the routing logic to pin datasource to nodes.
 2054        '''
 2055        self.healthy = healthy if healthy is not None else False
 2056        '''
 2057         True if the datasource is reachable and the credentials are valid.
 2058        '''
 2059        self.id = id if id is not None else ''
 2060        '''
 2061         Unique identifier of the Resource.
 2062        '''
 2063        self.name = name if name is not None else ''
 2064        '''
 2065         Unique human-readable name of the Resource.
 2066        '''
 2067        self.output = output if output is not None else ''
 2068        self.port_override = port_override if port_override is not None else 0
 2069        self.region = region if region is not None else ''
 2070        self.role_arn = role_arn if role_arn is not None else ''
 2071        self.role_external_id = role_external_id if role_external_id is not None else ''
 2072        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2073        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2074        '''
 2075         ID of the secret store containing credentials for this resource, if any.
 2076        '''
 2077        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2078        '''
 2079         Tags is a map of key, value pairs.
 2080        '''
 2081
 2082    def __repr__(self):
 2083        return '<sdm.Athena ' + \
 2084            'access_key: ' + repr(self.access_key) + ' ' +\
 2085            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2086            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2087            'healthy: ' + repr(self.healthy) + ' ' +\
 2088            'id: ' + repr(self.id) + ' ' +\
 2089            'name: ' + repr(self.name) + ' ' +\
 2090            'output: ' + repr(self.output) + ' ' +\
 2091            'port_override: ' + repr(self.port_override) + ' ' +\
 2092            'region: ' + repr(self.region) + ' ' +\
 2093            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2094            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2095            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2096            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2097            'tags: ' + repr(self.tags) + ' ' +\
 2098            '>'
 2099
 2100    def to_dict(self):
 2101        return {
 2102            'access_key': self.access_key,
 2103            'bind_interface': self.bind_interface,
 2104            'egress_filter': self.egress_filter,
 2105            'healthy': self.healthy,
 2106            'id': self.id,
 2107            'name': self.name,
 2108            'output': self.output,
 2109            'port_override': self.port_override,
 2110            'region': self.region,
 2111            'role_arn': self.role_arn,
 2112            'role_external_id': self.role_external_id,
 2113            'secret_access_key': self.secret_access_key,
 2114            'secret_store_id': self.secret_store_id,
 2115            'tags': self.tags,
 2116        }
 2117
 2118    @classmethod
 2119    def from_dict(cls, d):
 2120        return cls(
 2121            access_key=d.get('access_key'),
 2122            bind_interface=d.get('bind_interface'),
 2123            egress_filter=d.get('egress_filter'),
 2124            healthy=d.get('healthy'),
 2125            id=d.get('id'),
 2126            name=d.get('name'),
 2127            output=d.get('output'),
 2128            port_override=d.get('port_override'),
 2129            region=d.get('region'),
 2130            role_arn=d.get('role_arn'),
 2131            role_external_id=d.get('role_external_id'),
 2132            secret_access_key=d.get('secret_access_key'),
 2133            secret_store_id=d.get('secret_store_id'),
 2134            tags=d.get('tags'),
 2135        )
 2136
 2137
 2138class AuroraMysql:
 2139    __slots__ = [
 2140        'bind_interface',
 2141        'database',
 2142        'egress_filter',
 2143        'healthy',
 2144        'hostname',
 2145        'id',
 2146        'name',
 2147        'password',
 2148        'port',
 2149        'port_override',
 2150        'secret_store_id',
 2151        'tags',
 2152        'username',
 2153    ]
 2154
 2155    def __init__(
 2156        self,
 2157        bind_interface=None,
 2158        database=None,
 2159        egress_filter=None,
 2160        healthy=None,
 2161        hostname=None,
 2162        id=None,
 2163        name=None,
 2164        password=None,
 2165        port=None,
 2166        port_override=None,
 2167        secret_store_id=None,
 2168        tags=None,
 2169        username=None,
 2170    ):
 2171        self.bind_interface = bind_interface if bind_interface is not None else ''
 2172        '''
 2173         Bind interface
 2174        '''
 2175        self.database = database if database is not None else ''
 2176        self.egress_filter = egress_filter if egress_filter is not None else ''
 2177        '''
 2178         A filter applied to the routing logic to pin datasource to nodes.
 2179        '''
 2180        self.healthy = healthy if healthy is not None else False
 2181        '''
 2182         True if the datasource is reachable and the credentials are valid.
 2183        '''
 2184        self.hostname = hostname if hostname is not None else ''
 2185        self.id = id if id is not None else ''
 2186        '''
 2187         Unique identifier of the Resource.
 2188        '''
 2189        self.name = name if name is not None else ''
 2190        '''
 2191         Unique human-readable name of the Resource.
 2192        '''
 2193        self.password = password if password is not None else ''
 2194        self.port = port if port is not None else 0
 2195        self.port_override = port_override if port_override is not None else 0
 2196        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2197        '''
 2198         ID of the secret store containing credentials for this resource, if any.
 2199        '''
 2200        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2201        '''
 2202         Tags is a map of key, value pairs.
 2203        '''
 2204        self.username = username if username is not None else ''
 2205
 2206    def __repr__(self):
 2207        return '<sdm.AuroraMysql ' + \
 2208            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2209            'database: ' + repr(self.database) + ' ' +\
 2210            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2211            'healthy: ' + repr(self.healthy) + ' ' +\
 2212            'hostname: ' + repr(self.hostname) + ' ' +\
 2213            'id: ' + repr(self.id) + ' ' +\
 2214            'name: ' + repr(self.name) + ' ' +\
 2215            'password: ' + repr(self.password) + ' ' +\
 2216            'port: ' + repr(self.port) + ' ' +\
 2217            'port_override: ' + repr(self.port_override) + ' ' +\
 2218            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2219            'tags: ' + repr(self.tags) + ' ' +\
 2220            'username: ' + repr(self.username) + ' ' +\
 2221            '>'
 2222
 2223    def to_dict(self):
 2224        return {
 2225            'bind_interface': self.bind_interface,
 2226            'database': self.database,
 2227            'egress_filter': self.egress_filter,
 2228            'healthy': self.healthy,
 2229            'hostname': self.hostname,
 2230            'id': self.id,
 2231            'name': self.name,
 2232            'password': self.password,
 2233            'port': self.port,
 2234            'port_override': self.port_override,
 2235            'secret_store_id': self.secret_store_id,
 2236            'tags': self.tags,
 2237            'username': self.username,
 2238        }
 2239
 2240    @classmethod
 2241    def from_dict(cls, d):
 2242        return cls(
 2243            bind_interface=d.get('bind_interface'),
 2244            database=d.get('database'),
 2245            egress_filter=d.get('egress_filter'),
 2246            healthy=d.get('healthy'),
 2247            hostname=d.get('hostname'),
 2248            id=d.get('id'),
 2249            name=d.get('name'),
 2250            password=d.get('password'),
 2251            port=d.get('port'),
 2252            port_override=d.get('port_override'),
 2253            secret_store_id=d.get('secret_store_id'),
 2254            tags=d.get('tags'),
 2255            username=d.get('username'),
 2256        )
 2257
 2258
 2259class AuroraPostgres:
 2260    __slots__ = [
 2261        'bind_interface',
 2262        'database',
 2263        'egress_filter',
 2264        'healthy',
 2265        'hostname',
 2266        'id',
 2267        'name',
 2268        'override_database',
 2269        'password',
 2270        'port',
 2271        'port_override',
 2272        'secret_store_id',
 2273        'tags',
 2274        'username',
 2275    ]
 2276
 2277    def __init__(
 2278        self,
 2279        bind_interface=None,
 2280        database=None,
 2281        egress_filter=None,
 2282        healthy=None,
 2283        hostname=None,
 2284        id=None,
 2285        name=None,
 2286        override_database=None,
 2287        password=None,
 2288        port=None,
 2289        port_override=None,
 2290        secret_store_id=None,
 2291        tags=None,
 2292        username=None,
 2293    ):
 2294        self.bind_interface = bind_interface if bind_interface is not None else ''
 2295        '''
 2296         Bind interface
 2297        '''
 2298        self.database = database if database is not None else ''
 2299        self.egress_filter = egress_filter if egress_filter is not None else ''
 2300        '''
 2301         A filter applied to the routing logic to pin datasource to nodes.
 2302        '''
 2303        self.healthy = healthy if healthy is not None else False
 2304        '''
 2305         True if the datasource is reachable and the credentials are valid.
 2306        '''
 2307        self.hostname = hostname if hostname is not None else ''
 2308        self.id = id if id is not None else ''
 2309        '''
 2310         Unique identifier of the Resource.
 2311        '''
 2312        self.name = name if name is not None else ''
 2313        '''
 2314         Unique human-readable name of the Resource.
 2315        '''
 2316        self.override_database = override_database if override_database is not None else False
 2317        self.password = password if password is not None else ''
 2318        self.port = port if port is not None else 0
 2319        self.port_override = port_override if port_override is not None else 0
 2320        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2321        '''
 2322         ID of the secret store containing credentials for this resource, if any.
 2323        '''
 2324        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2325        '''
 2326         Tags is a map of key, value pairs.
 2327        '''
 2328        self.username = username if username is not None else ''
 2329
 2330    def __repr__(self):
 2331        return '<sdm.AuroraPostgres ' + \
 2332            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2333            'database: ' + repr(self.database) + ' ' +\
 2334            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2335            'healthy: ' + repr(self.healthy) + ' ' +\
 2336            'hostname: ' + repr(self.hostname) + ' ' +\
 2337            'id: ' + repr(self.id) + ' ' +\
 2338            'name: ' + repr(self.name) + ' ' +\
 2339            'override_database: ' + repr(self.override_database) + ' ' +\
 2340            'password: ' + repr(self.password) + ' ' +\
 2341            'port: ' + repr(self.port) + ' ' +\
 2342            'port_override: ' + repr(self.port_override) + ' ' +\
 2343            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2344            'tags: ' + repr(self.tags) + ' ' +\
 2345            'username: ' + repr(self.username) + ' ' +\
 2346            '>'
 2347
 2348    def to_dict(self):
 2349        return {
 2350            'bind_interface': self.bind_interface,
 2351            'database': self.database,
 2352            'egress_filter': self.egress_filter,
 2353            'healthy': self.healthy,
 2354            'hostname': self.hostname,
 2355            'id': self.id,
 2356            'name': self.name,
 2357            'override_database': self.override_database,
 2358            'password': self.password,
 2359            'port': self.port,
 2360            'port_override': self.port_override,
 2361            'secret_store_id': self.secret_store_id,
 2362            'tags': self.tags,
 2363            'username': self.username,
 2364        }
 2365
 2366    @classmethod
 2367    def from_dict(cls, d):
 2368        return cls(
 2369            bind_interface=d.get('bind_interface'),
 2370            database=d.get('database'),
 2371            egress_filter=d.get('egress_filter'),
 2372            healthy=d.get('healthy'),
 2373            hostname=d.get('hostname'),
 2374            id=d.get('id'),
 2375            name=d.get('name'),
 2376            override_database=d.get('override_database'),
 2377            password=d.get('password'),
 2378            port=d.get('port'),
 2379            port_override=d.get('port_override'),
 2380            secret_store_id=d.get('secret_store_id'),
 2381            tags=d.get('tags'),
 2382            username=d.get('username'),
 2383        )
 2384
 2385
 2386class Azure:
 2387    __slots__ = [
 2388        'app_id',
 2389        'bind_interface',
 2390        'egress_filter',
 2391        'healthy',
 2392        'id',
 2393        'name',
 2394        'password',
 2395        'secret_store_id',
 2396        'tags',
 2397        'tenant_id',
 2398    ]
 2399
 2400    def __init__(
 2401        self,
 2402        app_id=None,
 2403        bind_interface=None,
 2404        egress_filter=None,
 2405        healthy=None,
 2406        id=None,
 2407        name=None,
 2408        password=None,
 2409        secret_store_id=None,
 2410        tags=None,
 2411        tenant_id=None,
 2412    ):
 2413        self.app_id = app_id if app_id is not None else ''
 2414        self.bind_interface = bind_interface if bind_interface is not None else ''
 2415        '''
 2416         Bind interface
 2417        '''
 2418        self.egress_filter = egress_filter if egress_filter is not None else ''
 2419        '''
 2420         A filter applied to the routing logic to pin datasource to nodes.
 2421        '''
 2422        self.healthy = healthy if healthy is not None else False
 2423        '''
 2424         True if the datasource is reachable and the credentials are valid.
 2425        '''
 2426        self.id = id if id is not None else ''
 2427        '''
 2428         Unique identifier of the Resource.
 2429        '''
 2430        self.name = name if name is not None else ''
 2431        '''
 2432         Unique human-readable name of the Resource.
 2433        '''
 2434        self.password = password if password is not None else ''
 2435        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2436        '''
 2437         ID of the secret store containing credentials for this resource, if any.
 2438        '''
 2439        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2440        '''
 2441         Tags is a map of key, value pairs.
 2442        '''
 2443        self.tenant_id = tenant_id if tenant_id is not None else ''
 2444
 2445    def __repr__(self):
 2446        return '<sdm.Azure ' + \
 2447            'app_id: ' + repr(self.app_id) + ' ' +\
 2448            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2449            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2450            'healthy: ' + repr(self.healthy) + ' ' +\
 2451            'id: ' + repr(self.id) + ' ' +\
 2452            'name: ' + repr(self.name) + ' ' +\
 2453            'password: ' + repr(self.password) + ' ' +\
 2454            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2455            'tags: ' + repr(self.tags) + ' ' +\
 2456            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2457            '>'
 2458
 2459    def to_dict(self):
 2460        return {
 2461            'app_id': self.app_id,
 2462            'bind_interface': self.bind_interface,
 2463            'egress_filter': self.egress_filter,
 2464            'healthy': self.healthy,
 2465            'id': self.id,
 2466            'name': self.name,
 2467            'password': self.password,
 2468            'secret_store_id': self.secret_store_id,
 2469            'tags': self.tags,
 2470            'tenant_id': self.tenant_id,
 2471        }
 2472
 2473    @classmethod
 2474    def from_dict(cls, d):
 2475        return cls(
 2476            app_id=d.get('app_id'),
 2477            bind_interface=d.get('bind_interface'),
 2478            egress_filter=d.get('egress_filter'),
 2479            healthy=d.get('healthy'),
 2480            id=d.get('id'),
 2481            name=d.get('name'),
 2482            password=d.get('password'),
 2483            secret_store_id=d.get('secret_store_id'),
 2484            tags=d.get('tags'),
 2485            tenant_id=d.get('tenant_id'),
 2486        )
 2487
 2488
 2489class AzureCertificate:
 2490    __slots__ = [
 2491        'app_id',
 2492        'bind_interface',
 2493        'client_certificate',
 2494        'egress_filter',
 2495        'healthy',
 2496        'id',
 2497        'name',
 2498        'secret_store_id',
 2499        'tags',
 2500        'tenant_id',
 2501    ]
 2502
 2503    def __init__(
 2504        self,
 2505        app_id=None,
 2506        bind_interface=None,
 2507        client_certificate=None,
 2508        egress_filter=None,
 2509        healthy=None,
 2510        id=None,
 2511        name=None,
 2512        secret_store_id=None,
 2513        tags=None,
 2514        tenant_id=None,
 2515    ):
 2516        self.app_id = app_id if app_id is not None else ''
 2517        self.bind_interface = bind_interface if bind_interface is not None else ''
 2518        '''
 2519         Bind interface
 2520        '''
 2521        self.client_certificate = client_certificate if client_certificate is not None else ''
 2522        self.egress_filter = egress_filter if egress_filter is not None else ''
 2523        '''
 2524         A filter applied to the routing logic to pin datasource to nodes.
 2525        '''
 2526        self.healthy = healthy if healthy is not None else False
 2527        '''
 2528         True if the datasource is reachable and the credentials are valid.
 2529        '''
 2530        self.id = id if id is not None else ''
 2531        '''
 2532         Unique identifier of the Resource.
 2533        '''
 2534        self.name = name if name is not None else ''
 2535        '''
 2536         Unique human-readable name of the Resource.
 2537        '''
 2538        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2539        '''
 2540         ID of the secret store containing credentials for this resource, if any.
 2541        '''
 2542        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2543        '''
 2544         Tags is a map of key, value pairs.
 2545        '''
 2546        self.tenant_id = tenant_id if tenant_id is not None else ''
 2547
 2548    def __repr__(self):
 2549        return '<sdm.AzureCertificate ' + \
 2550            'app_id: ' + repr(self.app_id) + ' ' +\
 2551            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2552            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2553            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2554            'healthy: ' + repr(self.healthy) + ' ' +\
 2555            'id: ' + repr(self.id) + ' ' +\
 2556            'name: ' + repr(self.name) + ' ' +\
 2557            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2558            'tags: ' + repr(self.tags) + ' ' +\
 2559            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2560            '>'
 2561
 2562    def to_dict(self):
 2563        return {
 2564            'app_id': self.app_id,
 2565            'bind_interface': self.bind_interface,
 2566            'client_certificate': self.client_certificate,
 2567            'egress_filter': self.egress_filter,
 2568            'healthy': self.healthy,
 2569            'id': self.id,
 2570            'name': self.name,
 2571            'secret_store_id': self.secret_store_id,
 2572            'tags': self.tags,
 2573            'tenant_id': self.tenant_id,
 2574        }
 2575
 2576    @classmethod
 2577    def from_dict(cls, d):
 2578        return cls(
 2579            app_id=d.get('app_id'),
 2580            bind_interface=d.get('bind_interface'),
 2581            client_certificate=d.get('client_certificate'),
 2582            egress_filter=d.get('egress_filter'),
 2583            healthy=d.get('healthy'),
 2584            id=d.get('id'),
 2585            name=d.get('name'),
 2586            secret_store_id=d.get('secret_store_id'),
 2587            tags=d.get('tags'),
 2588            tenant_id=d.get('tenant_id'),
 2589        )
 2590
 2591
 2592class AzurePostgres:
 2593    __slots__ = [
 2594        'bind_interface',
 2595        'database',
 2596        'egress_filter',
 2597        'healthy',
 2598        'hostname',
 2599        'id',
 2600        'name',
 2601        'override_database',
 2602        'password',
 2603        'port',
 2604        'port_override',
 2605        'secret_store_id',
 2606        'tags',
 2607        'username',
 2608    ]
 2609
 2610    def __init__(
 2611        self,
 2612        bind_interface=None,
 2613        database=None,
 2614        egress_filter=None,
 2615        healthy=None,
 2616        hostname=None,
 2617        id=None,
 2618        name=None,
 2619        override_database=None,
 2620        password=None,
 2621        port=None,
 2622        port_override=None,
 2623        secret_store_id=None,
 2624        tags=None,
 2625        username=None,
 2626    ):
 2627        self.bind_interface = bind_interface if bind_interface is not None else ''
 2628        '''
 2629         Bind interface
 2630        '''
 2631        self.database = database if database is not None else ''
 2632        self.egress_filter = egress_filter if egress_filter is not None else ''
 2633        '''
 2634         A filter applied to the routing logic to pin datasource to nodes.
 2635        '''
 2636        self.healthy = healthy if healthy is not None else False
 2637        '''
 2638         True if the datasource is reachable and the credentials are valid.
 2639        '''
 2640        self.hostname = hostname if hostname is not None else ''
 2641        self.id = id if id is not None else ''
 2642        '''
 2643         Unique identifier of the Resource.
 2644        '''
 2645        self.name = name if name is not None else ''
 2646        '''
 2647         Unique human-readable name of the Resource.
 2648        '''
 2649        self.override_database = override_database if override_database is not None else False
 2650        self.password = password if password is not None else ''
 2651        self.port = port if port is not None else 0
 2652        self.port_override = port_override if port_override is not None else 0
 2653        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2654        '''
 2655         ID of the secret store containing credentials for this resource, if any.
 2656        '''
 2657        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2658        '''
 2659         Tags is a map of key, value pairs.
 2660        '''
 2661        self.username = username if username is not None else ''
 2662
 2663    def __repr__(self):
 2664        return '<sdm.AzurePostgres ' + \
 2665            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2666            'database: ' + repr(self.database) + ' ' +\
 2667            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2668            'healthy: ' + repr(self.healthy) + ' ' +\
 2669            'hostname: ' + repr(self.hostname) + ' ' +\
 2670            'id: ' + repr(self.id) + ' ' +\
 2671            'name: ' + repr(self.name) + ' ' +\
 2672            'override_database: ' + repr(self.override_database) + ' ' +\
 2673            'password: ' + repr(self.password) + ' ' +\
 2674            'port: ' + repr(self.port) + ' ' +\
 2675            'port_override: ' + repr(self.port_override) + ' ' +\
 2676            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2677            'tags: ' + repr(self.tags) + ' ' +\
 2678            'username: ' + repr(self.username) + ' ' +\
 2679            '>'
 2680
 2681    def to_dict(self):
 2682        return {
 2683            'bind_interface': self.bind_interface,
 2684            'database': self.database,
 2685            'egress_filter': self.egress_filter,
 2686            'healthy': self.healthy,
 2687            'hostname': self.hostname,
 2688            'id': self.id,
 2689            'name': self.name,
 2690            'override_database': self.override_database,
 2691            'password': self.password,
 2692            'port': self.port,
 2693            'port_override': self.port_override,
 2694            'secret_store_id': self.secret_store_id,
 2695            'tags': self.tags,
 2696            'username': self.username,
 2697        }
 2698
 2699    @classmethod
 2700    def from_dict(cls, d):
 2701        return cls(
 2702            bind_interface=d.get('bind_interface'),
 2703            database=d.get('database'),
 2704            egress_filter=d.get('egress_filter'),
 2705            healthy=d.get('healthy'),
 2706            hostname=d.get('hostname'),
 2707            id=d.get('id'),
 2708            name=d.get('name'),
 2709            override_database=d.get('override_database'),
 2710            password=d.get('password'),
 2711            port=d.get('port'),
 2712            port_override=d.get('port_override'),
 2713            secret_store_id=d.get('secret_store_id'),
 2714            tags=d.get('tags'),
 2715            username=d.get('username'),
 2716        )
 2717
 2718
 2719class AzureStore:
 2720    __slots__ = [
 2721        'id',
 2722        'name',
 2723        'tags',
 2724        'vault_uri',
 2725    ]
 2726
 2727    def __init__(
 2728        self,
 2729        id=None,
 2730        name=None,
 2731        tags=None,
 2732        vault_uri=None,
 2733    ):
 2734        self.id = id if id is not None else ''
 2735        '''
 2736         Unique identifier of the SecretStore.
 2737        '''
 2738        self.name = name if name is not None else ''
 2739        '''
 2740         Unique human-readable name of the SecretStore.
 2741        '''
 2742        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2743        '''
 2744         Tags is a map of key, value pairs.
 2745        '''
 2746        self.vault_uri = vault_uri if vault_uri is not None else ''
 2747
 2748    def __repr__(self):
 2749        return '<sdm.AzureStore ' + \
 2750            'id: ' + repr(self.id) + ' ' +\
 2751            'name: ' + repr(self.name) + ' ' +\
 2752            'tags: ' + repr(self.tags) + ' ' +\
 2753            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 2754            '>'
 2755
 2756    def to_dict(self):
 2757        return {
 2758            'id': self.id,
 2759            'name': self.name,
 2760            'tags': self.tags,
 2761            'vault_uri': self.vault_uri,
 2762        }
 2763
 2764    @classmethod
 2765    def from_dict(cls, d):
 2766        return cls(
 2767            id=d.get('id'),
 2768            name=d.get('name'),
 2769            tags=d.get('tags'),
 2770            vault_uri=d.get('vault_uri'),
 2771        )
 2772
 2773
 2774class BigQuery:
 2775    __slots__ = [
 2776        'bind_interface',
 2777        'egress_filter',
 2778        'endpoint',
 2779        'healthy',
 2780        'id',
 2781        'name',
 2782        'port_override',
 2783        'private_key',
 2784        'project',
 2785        'secret_store_id',
 2786        'tags',
 2787        'username',
 2788    ]
 2789
 2790    def __init__(
 2791        self,
 2792        bind_interface=None,
 2793        egress_filter=None,
 2794        endpoint=None,
 2795        healthy=None,
 2796        id=None,
 2797        name=None,
 2798        port_override=None,
 2799        private_key=None,
 2800        project=None,
 2801        secret_store_id=None,
 2802        tags=None,
 2803        username=None,
 2804    ):
 2805        self.bind_interface = bind_interface if bind_interface is not None else ''
 2806        '''
 2807         Bind interface
 2808        '''
 2809        self.egress_filter = egress_filter if egress_filter is not None else ''
 2810        '''
 2811         A filter applied to the routing logic to pin datasource to nodes.
 2812        '''
 2813        self.endpoint = endpoint if endpoint is not None else ''
 2814        self.healthy = healthy if healthy is not None else False
 2815        '''
 2816         True if the datasource is reachable and the credentials are valid.
 2817        '''
 2818        self.id = id if id is not None else ''
 2819        '''
 2820         Unique identifier of the Resource.
 2821        '''
 2822        self.name = name if name is not None else ''
 2823        '''
 2824         Unique human-readable name of the Resource.
 2825        '''
 2826        self.port_override = port_override if port_override is not None else 0
 2827        self.private_key = private_key if private_key is not None else ''
 2828        self.project = project if project is not None else ''
 2829        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2830        '''
 2831         ID of the secret store containing credentials for this resource, if any.
 2832        '''
 2833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2834        '''
 2835         Tags is a map of key, value pairs.
 2836        '''
 2837        self.username = username if username is not None else ''
 2838
 2839    def __repr__(self):
 2840        return '<sdm.BigQuery ' + \
 2841            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2842            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2843            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2844            'healthy: ' + repr(self.healthy) + ' ' +\
 2845            'id: ' + repr(self.id) + ' ' +\
 2846            'name: ' + repr(self.name) + ' ' +\
 2847            'port_override: ' + repr(self.port_override) + ' ' +\
 2848            'private_key: ' + repr(self.private_key) + ' ' +\
 2849            'project: ' + repr(self.project) + ' ' +\
 2850            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2851            'tags: ' + repr(self.tags) + ' ' +\
 2852            'username: ' + repr(self.username) + ' ' +\
 2853            '>'
 2854
 2855    def to_dict(self):
 2856        return {
 2857            'bind_interface': self.bind_interface,
 2858            'egress_filter': self.egress_filter,
 2859            'endpoint': self.endpoint,
 2860            'healthy': self.healthy,
 2861            'id': self.id,
 2862            'name': self.name,
 2863            'port_override': self.port_override,
 2864            'private_key': self.private_key,
 2865            'project': self.project,
 2866            'secret_store_id': self.secret_store_id,
 2867            'tags': self.tags,
 2868            'username': self.username,
 2869        }
 2870
 2871    @classmethod
 2872    def from_dict(cls, d):
 2873        return cls(
 2874            bind_interface=d.get('bind_interface'),
 2875            egress_filter=d.get('egress_filter'),
 2876            endpoint=d.get('endpoint'),
 2877            healthy=d.get('healthy'),
 2878            id=d.get('id'),
 2879            name=d.get('name'),
 2880            port_override=d.get('port_override'),
 2881            private_key=d.get('private_key'),
 2882            project=d.get('project'),
 2883            secret_store_id=d.get('secret_store_id'),
 2884            tags=d.get('tags'),
 2885            username=d.get('username'),
 2886        )
 2887
 2888
 2889class Cassandra:
 2890    __slots__ = [
 2891        'bind_interface',
 2892        'egress_filter',
 2893        'healthy',
 2894        'hostname',
 2895        'id',
 2896        'name',
 2897        'password',
 2898        'port',
 2899        'port_override',
 2900        'secret_store_id',
 2901        'tags',
 2902        'tls_required',
 2903        'username',
 2904    ]
 2905
 2906    def __init__(
 2907        self,
 2908        bind_interface=None,
 2909        egress_filter=None,
 2910        healthy=None,
 2911        hostname=None,
 2912        id=None,
 2913        name=None,
 2914        password=None,
 2915        port=None,
 2916        port_override=None,
 2917        secret_store_id=None,
 2918        tags=None,
 2919        tls_required=None,
 2920        username=None,
 2921    ):
 2922        self.bind_interface = bind_interface if bind_interface is not None else ''
 2923        '''
 2924         Bind interface
 2925        '''
 2926        self.egress_filter = egress_filter if egress_filter is not None else ''
 2927        '''
 2928         A filter applied to the routing logic to pin datasource to nodes.
 2929        '''
 2930        self.healthy = healthy if healthy is not None else False
 2931        '''
 2932         True if the datasource is reachable and the credentials are valid.
 2933        '''
 2934        self.hostname = hostname if hostname is not None else ''
 2935        self.id = id if id is not None else ''
 2936        '''
 2937         Unique identifier of the Resource.
 2938        '''
 2939        self.name = name if name is not None else ''
 2940        '''
 2941         Unique human-readable name of the Resource.
 2942        '''
 2943        self.password = password if password is not None else ''
 2944        self.port = port if port is not None else 0
 2945        self.port_override = port_override if port_override is not None else 0
 2946        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2947        '''
 2948         ID of the secret store containing credentials for this resource, if any.
 2949        '''
 2950        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2951        '''
 2952         Tags is a map of key, value pairs.
 2953        '''
 2954        self.tls_required = tls_required if tls_required is not None else False
 2955        self.username = username if username is not None else ''
 2956
 2957    def __repr__(self):
 2958        return '<sdm.Cassandra ' + \
 2959            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2960            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2961            'healthy: ' + repr(self.healthy) + ' ' +\
 2962            'hostname: ' + repr(self.hostname) + ' ' +\
 2963            'id: ' + repr(self.id) + ' ' +\
 2964            'name: ' + repr(self.name) + ' ' +\
 2965            'password: ' + repr(self.password) + ' ' +\
 2966            'port: ' + repr(self.port) + ' ' +\
 2967            'port_override: ' + repr(self.port_override) + ' ' +\
 2968            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2969            'tags: ' + repr(self.tags) + ' ' +\
 2970            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2971            'username: ' + repr(self.username) + ' ' +\
 2972            '>'
 2973
 2974    def to_dict(self):
 2975        return {
 2976            'bind_interface': self.bind_interface,
 2977            'egress_filter': self.egress_filter,
 2978            'healthy': self.healthy,
 2979            'hostname': self.hostname,
 2980            'id': self.id,
 2981            'name': self.name,
 2982            'password': self.password,
 2983            'port': self.port,
 2984            'port_override': self.port_override,
 2985            'secret_store_id': self.secret_store_id,
 2986            'tags': self.tags,
 2987            'tls_required': self.tls_required,
 2988            'username': self.username,
 2989        }
 2990
 2991    @classmethod
 2992    def from_dict(cls, d):
 2993        return cls(
 2994            bind_interface=d.get('bind_interface'),
 2995            egress_filter=d.get('egress_filter'),
 2996            healthy=d.get('healthy'),
 2997            hostname=d.get('hostname'),
 2998            id=d.get('id'),
 2999            name=d.get('name'),
 3000            password=d.get('password'),
 3001            port=d.get('port'),
 3002            port_override=d.get('port_override'),
 3003            secret_store_id=d.get('secret_store_id'),
 3004            tags=d.get('tags'),
 3005            tls_required=d.get('tls_required'),
 3006            username=d.get('username'),
 3007        )
 3008
 3009
 3010class Citus:
 3011    __slots__ = [
 3012        'bind_interface',
 3013        'database',
 3014        'egress_filter',
 3015        'healthy',
 3016        'hostname',
 3017        'id',
 3018        'name',
 3019        'override_database',
 3020        'password',
 3021        'port',
 3022        'port_override',
 3023        'secret_store_id',
 3024        'tags',
 3025        'username',
 3026    ]
 3027
 3028    def __init__(
 3029        self,
 3030        bind_interface=None,
 3031        database=None,
 3032        egress_filter=None,
 3033        healthy=None,
 3034        hostname=None,
 3035        id=None,
 3036        name=None,
 3037        override_database=None,
 3038        password=None,
 3039        port=None,
 3040        port_override=None,
 3041        secret_store_id=None,
 3042        tags=None,
 3043        username=None,
 3044    ):
 3045        self.bind_interface = bind_interface if bind_interface is not None else ''
 3046        '''
 3047         Bind interface
 3048        '''
 3049        self.database = database if database is not None else ''
 3050        self.egress_filter = egress_filter if egress_filter is not None else ''
 3051        '''
 3052         A filter applied to the routing logic to pin datasource to nodes.
 3053        '''
 3054        self.healthy = healthy if healthy is not None else False
 3055        '''
 3056         True if the datasource is reachable and the credentials are valid.
 3057        '''
 3058        self.hostname = hostname if hostname is not None else ''
 3059        self.id = id if id is not None else ''
 3060        '''
 3061         Unique identifier of the Resource.
 3062        '''
 3063        self.name = name if name is not None else ''
 3064        '''
 3065         Unique human-readable name of the Resource.
 3066        '''
 3067        self.override_database = override_database if override_database is not None else False
 3068        self.password = password if password is not None else ''
 3069        self.port = port if port is not None else 0
 3070        self.port_override = port_override if port_override is not None else 0
 3071        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3072        '''
 3073         ID of the secret store containing credentials for this resource, if any.
 3074        '''
 3075        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3076        '''
 3077         Tags is a map of key, value pairs.
 3078        '''
 3079        self.username = username if username is not None else ''
 3080
 3081    def __repr__(self):
 3082        return '<sdm.Citus ' + \
 3083            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3084            'database: ' + repr(self.database) + ' ' +\
 3085            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3086            'healthy: ' + repr(self.healthy) + ' ' +\
 3087            'hostname: ' + repr(self.hostname) + ' ' +\
 3088            'id: ' + repr(self.id) + ' ' +\
 3089            'name: ' + repr(self.name) + ' ' +\
 3090            'override_database: ' + repr(self.override_database) + ' ' +\
 3091            'password: ' + repr(self.password) + ' ' +\
 3092            'port: ' + repr(self.port) + ' ' +\
 3093            'port_override: ' + repr(self.port_override) + ' ' +\
 3094            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3095            'tags: ' + repr(self.tags) + ' ' +\
 3096            'username: ' + repr(self.username) + ' ' +\
 3097            '>'
 3098
 3099    def to_dict(self):
 3100        return {
 3101            'bind_interface': self.bind_interface,
 3102            'database': self.database,
 3103            'egress_filter': self.egress_filter,
 3104            'healthy': self.healthy,
 3105            'hostname': self.hostname,
 3106            'id': self.id,
 3107            'name': self.name,
 3108            'override_database': self.override_database,
 3109            'password': self.password,
 3110            'port': self.port,
 3111            'port_override': self.port_override,
 3112            'secret_store_id': self.secret_store_id,
 3113            'tags': self.tags,
 3114            'username': self.username,
 3115        }
 3116
 3117    @classmethod
 3118    def from_dict(cls, d):
 3119        return cls(
 3120            bind_interface=d.get('bind_interface'),
 3121            database=d.get('database'),
 3122            egress_filter=d.get('egress_filter'),
 3123            healthy=d.get('healthy'),
 3124            hostname=d.get('hostname'),
 3125            id=d.get('id'),
 3126            name=d.get('name'),
 3127            override_database=d.get('override_database'),
 3128            password=d.get('password'),
 3129            port=d.get('port'),
 3130            port_override=d.get('port_override'),
 3131            secret_store_id=d.get('secret_store_id'),
 3132            tags=d.get('tags'),
 3133            username=d.get('username'),
 3134        )
 3135
 3136
 3137class Clustrix:
 3138    __slots__ = [
 3139        'bind_interface',
 3140        'database',
 3141        'egress_filter',
 3142        'healthy',
 3143        'hostname',
 3144        'id',
 3145        'name',
 3146        'password',
 3147        'port',
 3148        'port_override',
 3149        'secret_store_id',
 3150        'tags',
 3151        'username',
 3152    ]
 3153
 3154    def __init__(
 3155        self,
 3156        bind_interface=None,
 3157        database=None,
 3158        egress_filter=None,
 3159        healthy=None,
 3160        hostname=None,
 3161        id=None,
 3162        name=None,
 3163        password=None,
 3164        port=None,
 3165        port_override=None,
 3166        secret_store_id=None,
 3167        tags=None,
 3168        username=None,
 3169    ):
 3170        self.bind_interface = bind_interface if bind_interface is not None else ''
 3171        '''
 3172         Bind interface
 3173        '''
 3174        self.database = database if database is not None else ''
 3175        self.egress_filter = egress_filter if egress_filter is not None else ''
 3176        '''
 3177         A filter applied to the routing logic to pin datasource to nodes.
 3178        '''
 3179        self.healthy = healthy if healthy is not None else False
 3180        '''
 3181         True if the datasource is reachable and the credentials are valid.
 3182        '''
 3183        self.hostname = hostname if hostname is not None else ''
 3184        self.id = id if id is not None else ''
 3185        '''
 3186         Unique identifier of the Resource.
 3187        '''
 3188        self.name = name if name is not None else ''
 3189        '''
 3190         Unique human-readable name of the Resource.
 3191        '''
 3192        self.password = password if password is not None else ''
 3193        self.port = port if port is not None else 0
 3194        self.port_override = port_override if port_override is not None else 0
 3195        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3196        '''
 3197         ID of the secret store containing credentials for this resource, if any.
 3198        '''
 3199        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3200        '''
 3201         Tags is a map of key, value pairs.
 3202        '''
 3203        self.username = username if username is not None else ''
 3204
 3205    def __repr__(self):
 3206        return '<sdm.Clustrix ' + \
 3207            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3208            'database: ' + repr(self.database) + ' ' +\
 3209            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3210            'healthy: ' + repr(self.healthy) + ' ' +\
 3211            'hostname: ' + repr(self.hostname) + ' ' +\
 3212            'id: ' + repr(self.id) + ' ' +\
 3213            'name: ' + repr(self.name) + ' ' +\
 3214            'password: ' + repr(self.password) + ' ' +\
 3215            'port: ' + repr(self.port) + ' ' +\
 3216            'port_override: ' + repr(self.port_override) + ' ' +\
 3217            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3218            'tags: ' + repr(self.tags) + ' ' +\
 3219            'username: ' + repr(self.username) + ' ' +\
 3220            '>'
 3221
 3222    def to_dict(self):
 3223        return {
 3224            'bind_interface': self.bind_interface,
 3225            'database': self.database,
 3226            'egress_filter': self.egress_filter,
 3227            'healthy': self.healthy,
 3228            'hostname': self.hostname,
 3229            'id': self.id,
 3230            'name': self.name,
 3231            'password': self.password,
 3232            'port': self.port,
 3233            'port_override': self.port_override,
 3234            'secret_store_id': self.secret_store_id,
 3235            'tags': self.tags,
 3236            'username': self.username,
 3237        }
 3238
 3239    @classmethod
 3240    def from_dict(cls, d):
 3241        return cls(
 3242            bind_interface=d.get('bind_interface'),
 3243            database=d.get('database'),
 3244            egress_filter=d.get('egress_filter'),
 3245            healthy=d.get('healthy'),
 3246            hostname=d.get('hostname'),
 3247            id=d.get('id'),
 3248            name=d.get('name'),
 3249            password=d.get('password'),
 3250            port=d.get('port'),
 3251            port_override=d.get('port_override'),
 3252            secret_store_id=d.get('secret_store_id'),
 3253            tags=d.get('tags'),
 3254            username=d.get('username'),
 3255        )
 3256
 3257
 3258class Cockroach:
 3259    __slots__ = [
 3260        'bind_interface',
 3261        'database',
 3262        'egress_filter',
 3263        'healthy',
 3264        'hostname',
 3265        'id',
 3266        'name',
 3267        'override_database',
 3268        'password',
 3269        'port',
 3270        'port_override',
 3271        'secret_store_id',
 3272        'tags',
 3273        'username',
 3274    ]
 3275
 3276    def __init__(
 3277        self,
 3278        bind_interface=None,
 3279        database=None,
 3280        egress_filter=None,
 3281        healthy=None,
 3282        hostname=None,
 3283        id=None,
 3284        name=None,
 3285        override_database=None,
 3286        password=None,
 3287        port=None,
 3288        port_override=None,
 3289        secret_store_id=None,
 3290        tags=None,
 3291        username=None,
 3292    ):
 3293        self.bind_interface = bind_interface if bind_interface is not None else ''
 3294        '''
 3295         Bind interface
 3296        '''
 3297        self.database = database if database is not None else ''
 3298        self.egress_filter = egress_filter if egress_filter is not None else ''
 3299        '''
 3300         A filter applied to the routing logic to pin datasource to nodes.
 3301        '''
 3302        self.healthy = healthy if healthy is not None else False
 3303        '''
 3304         True if the datasource is reachable and the credentials are valid.
 3305        '''
 3306        self.hostname = hostname if hostname is not None else ''
 3307        self.id = id if id is not None else ''
 3308        '''
 3309         Unique identifier of the Resource.
 3310        '''
 3311        self.name = name if name is not None else ''
 3312        '''
 3313         Unique human-readable name of the Resource.
 3314        '''
 3315        self.override_database = override_database if override_database is not None else False
 3316        self.password = password if password is not None else ''
 3317        self.port = port if port is not None else 0
 3318        self.port_override = port_override if port_override is not None else 0
 3319        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3320        '''
 3321         ID of the secret store containing credentials for this resource, if any.
 3322        '''
 3323        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3324        '''
 3325         Tags is a map of key, value pairs.
 3326        '''
 3327        self.username = username if username is not None else ''
 3328
 3329    def __repr__(self):
 3330        return '<sdm.Cockroach ' + \
 3331            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3332            'database: ' + repr(self.database) + ' ' +\
 3333            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3334            'healthy: ' + repr(self.healthy) + ' ' +\
 3335            'hostname: ' + repr(self.hostname) + ' ' +\
 3336            'id: ' + repr(self.id) + ' ' +\
 3337            'name: ' + repr(self.name) + ' ' +\
 3338            'override_database: ' + repr(self.override_database) + ' ' +\
 3339            'password: ' + repr(self.password) + ' ' +\
 3340            'port: ' + repr(self.port) + ' ' +\
 3341            'port_override: ' + repr(self.port_override) + ' ' +\
 3342            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3343            'tags: ' + repr(self.tags) + ' ' +\
 3344            'username: ' + repr(self.username) + ' ' +\
 3345            '>'
 3346
 3347    def to_dict(self):
 3348        return {
 3349            'bind_interface': self.bind_interface,
 3350            'database': self.database,
 3351            'egress_filter': self.egress_filter,
 3352            'healthy': self.healthy,
 3353            'hostname': self.hostname,
 3354            'id': self.id,
 3355            'name': self.name,
 3356            'override_database': self.override_database,
 3357            'password': self.password,
 3358            'port': self.port,
 3359            'port_override': self.port_override,
 3360            'secret_store_id': self.secret_store_id,
 3361            'tags': self.tags,
 3362            'username': self.username,
 3363        }
 3364
 3365    @classmethod
 3366    def from_dict(cls, d):
 3367        return cls(
 3368            bind_interface=d.get('bind_interface'),
 3369            database=d.get('database'),
 3370            egress_filter=d.get('egress_filter'),
 3371            healthy=d.get('healthy'),
 3372            hostname=d.get('hostname'),
 3373            id=d.get('id'),
 3374            name=d.get('name'),
 3375            override_database=d.get('override_database'),
 3376            password=d.get('password'),
 3377            port=d.get('port'),
 3378            port_override=d.get('port_override'),
 3379            secret_store_id=d.get('secret_store_id'),
 3380            tags=d.get('tags'),
 3381            username=d.get('username'),
 3382        )
 3383
 3384
 3385class ConjurStore:
 3386    '''
 3387    ConjurStore is currently unstable, and its API may change, or it may be removed,
 3388    without a major version bump.
 3389    '''
 3390    __slots__ = [
 3391        'appurl',
 3392        'id',
 3393        'name',
 3394        'tags',
 3395    ]
 3396
 3397    def __init__(
 3398        self,
 3399        appurl=None,
 3400        id=None,
 3401        name=None,
 3402        tags=None,
 3403    ):
 3404        self.appurl = appurl if appurl is not None else ''
 3405        self.id = id if id is not None else ''
 3406        '''
 3407         Unique identifier of the SecretStore.
 3408        '''
 3409        self.name = name if name is not None else ''
 3410        '''
 3411         Unique human-readable name of the SecretStore.
 3412        '''
 3413        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3414        '''
 3415         Tags is a map of key, value pairs.
 3416        '''
 3417
 3418    def __repr__(self):
 3419        return '<sdm.ConjurStore ' + \
 3420            'appurl: ' + repr(self.appurl) + ' ' +\
 3421            'id: ' + repr(self.id) + ' ' +\
 3422            'name: ' + repr(self.name) + ' ' +\
 3423            'tags: ' + repr(self.tags) + ' ' +\
 3424            '>'
 3425
 3426    def to_dict(self):
 3427        return {
 3428            'appurl': self.appurl,
 3429            'id': self.id,
 3430            'name': self.name,
 3431            'tags': self.tags,
 3432        }
 3433
 3434    @classmethod
 3435    def from_dict(cls, d):
 3436        return cls(
 3437            appurl=d.get('appurl'),
 3438            id=d.get('id'),
 3439            name=d.get('name'),
 3440            tags=d.get('tags'),
 3441        )
 3442
 3443
 3444class ControlPanelGetSSHCAPublicKeyResponse:
 3445    '''
 3446         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3447     organization's SSH Certificate Authority public key.
 3448    '''
 3449    __slots__ = [
 3450        'meta',
 3451        'public_key',
 3452        'rate_limit',
 3453    ]
 3454
 3455    def __init__(
 3456        self,
 3457        meta=None,
 3458        public_key=None,
 3459        rate_limit=None,
 3460    ):
 3461        self.meta = meta if meta is not None else None
 3462        '''
 3463         Reserved for future use.
 3464        '''
 3465        self.public_key = public_key if public_key is not None else ''
 3466        '''
 3467         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3468         key format.
 3469        '''
 3470        self.rate_limit = rate_limit if rate_limit is not None else None
 3471        '''
 3472         Rate limit information.
 3473        '''
 3474
 3475    def __repr__(self):
 3476        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3477            'meta: ' + repr(self.meta) + ' ' +\
 3478            'public_key: ' + repr(self.public_key) + ' ' +\
 3479            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3480            '>'
 3481
 3482    def to_dict(self):
 3483        return {
 3484            'meta': self.meta,
 3485            'public_key': self.public_key,
 3486            'rate_limit': self.rate_limit,
 3487        }
 3488
 3489    @classmethod
 3490    def from_dict(cls, d):
 3491        return cls(
 3492            meta=d.get('meta'),
 3493            public_key=d.get('public_key'),
 3494            rate_limit=d.get('rate_limit'),
 3495        )
 3496
 3497
 3498class ControlPanelVerifyJWTResponse:
 3499    '''
 3500         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3501    '''
 3502    __slots__ = [
 3503        'meta',
 3504        'rate_limit',
 3505        'valid',
 3506    ]
 3507
 3508    def __init__(
 3509        self,
 3510        meta=None,
 3511        rate_limit=None,
 3512        valid=None,
 3513    ):
 3514        self.meta = meta if meta is not None else None
 3515        '''
 3516         Reserved for future use.
 3517        '''
 3518        self.rate_limit = rate_limit if rate_limit is not None else None
 3519        '''
 3520         Rate limit information.
 3521        '''
 3522        self.valid = valid if valid is not None else False
 3523        '''
 3524         Reports if the given token is valid.
 3525        '''
 3526
 3527    def __repr__(self):
 3528        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3529            'meta: ' + repr(self.meta) + ' ' +\
 3530            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3531            'valid: ' + repr(self.valid) + ' ' +\
 3532            '>'
 3533
 3534    def to_dict(self):
 3535        return {
 3536            'meta': self.meta,
 3537            'rate_limit': self.rate_limit,
 3538            'valid': self.valid,
 3539        }
 3540
 3541    @classmethod
 3542    def from_dict(cls, d):
 3543        return cls(
 3544            meta=d.get('meta'),
 3545            rate_limit=d.get('rate_limit'),
 3546            valid=d.get('valid'),
 3547        )
 3548
 3549
 3550class CreateResponseMetadata:
 3551    '''
 3552         CreateResponseMetadata is reserved for future use.
 3553    '''
 3554    __slots__ = []
 3555
 3556    def __init__(self, ):
 3557        pass
 3558
 3559    def __repr__(self):
 3560        return '<sdm.CreateResponseMetadata ' + \
 3561            '>'
 3562
 3563    def to_dict(self):
 3564        return {}
 3565
 3566    @classmethod
 3567    def from_dict(cls, d):
 3568        return cls()
 3569
 3570
 3571class DB2I:
 3572    __slots__ = [
 3573        'bind_interface',
 3574        'egress_filter',
 3575        'healthy',
 3576        'hostname',
 3577        'id',
 3578        'name',
 3579        'password',
 3580        'port',
 3581        'port_override',
 3582        'secret_store_id',
 3583        'tags',
 3584        'tls_required',
 3585        'username',
 3586    ]
 3587
 3588    def __init__(
 3589        self,
 3590        bind_interface=None,
 3591        egress_filter=None,
 3592        healthy=None,
 3593        hostname=None,
 3594        id=None,
 3595        name=None,
 3596        password=None,
 3597        port=None,
 3598        port_override=None,
 3599        secret_store_id=None,
 3600        tags=None,
 3601        tls_required=None,
 3602        username=None,
 3603    ):
 3604        self.bind_interface = bind_interface if bind_interface is not None else ''
 3605        '''
 3606         Bind interface
 3607        '''
 3608        self.egress_filter = egress_filter if egress_filter is not None else ''
 3609        '''
 3610         A filter applied to the routing logic to pin datasource to nodes.
 3611        '''
 3612        self.healthy = healthy if healthy is not None else False
 3613        '''
 3614         True if the datasource is reachable and the credentials are valid.
 3615        '''
 3616        self.hostname = hostname if hostname is not None else ''
 3617        self.id = id if id is not None else ''
 3618        '''
 3619         Unique identifier of the Resource.
 3620        '''
 3621        self.name = name if name is not None else ''
 3622        '''
 3623         Unique human-readable name of the Resource.
 3624        '''
 3625        self.password = password if password is not None else ''
 3626        self.port = port if port is not None else 0
 3627        self.port_override = port_override if port_override is not None else 0
 3628        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3629        '''
 3630         ID of the secret store containing credentials for this resource, if any.
 3631        '''
 3632        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3633        '''
 3634         Tags is a map of key, value pairs.
 3635        '''
 3636        self.tls_required = tls_required if tls_required is not None else False
 3637        self.username = username if username is not None else ''
 3638
 3639    def __repr__(self):
 3640        return '<sdm.DB2I ' + \
 3641            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3642            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3643            'healthy: ' + repr(self.healthy) + ' ' +\
 3644            'hostname: ' + repr(self.hostname) + ' ' +\
 3645            'id: ' + repr(self.id) + ' ' +\
 3646            'name: ' + repr(self.name) + ' ' +\
 3647            'password: ' + repr(self.password) + ' ' +\
 3648            'port: ' + repr(self.port) + ' ' +\
 3649            'port_override: ' + repr(self.port_override) + ' ' +\
 3650            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3651            'tags: ' + repr(self.tags) + ' ' +\
 3652            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3653            'username: ' + repr(self.username) + ' ' +\
 3654            '>'
 3655
 3656    def to_dict(self):
 3657        return {
 3658            'bind_interface': self.bind_interface,
 3659            'egress_filter': self.egress_filter,
 3660            'healthy': self.healthy,
 3661            'hostname': self.hostname,
 3662            'id': self.id,
 3663            'name': self.name,
 3664            'password': self.password,
 3665            'port': self.port,
 3666            'port_override': self.port_override,
 3667            'secret_store_id': self.secret_store_id,
 3668            'tags': self.tags,
 3669            'tls_required': self.tls_required,
 3670            'username': self.username,
 3671        }
 3672
 3673    @classmethod
 3674    def from_dict(cls, d):
 3675        return cls(
 3676            bind_interface=d.get('bind_interface'),
 3677            egress_filter=d.get('egress_filter'),
 3678            healthy=d.get('healthy'),
 3679            hostname=d.get('hostname'),
 3680            id=d.get('id'),
 3681            name=d.get('name'),
 3682            password=d.get('password'),
 3683            port=d.get('port'),
 3684            port_override=d.get('port_override'),
 3685            secret_store_id=d.get('secret_store_id'),
 3686            tags=d.get('tags'),
 3687            tls_required=d.get('tls_required'),
 3688            username=d.get('username'),
 3689        )
 3690
 3691
 3692class DB2LUW:
 3693    __slots__ = [
 3694        'bind_interface',
 3695        'database',
 3696        'egress_filter',
 3697        'healthy',
 3698        'hostname',
 3699        'id',
 3700        'name',
 3701        'password',
 3702        'port',
 3703        'port_override',
 3704        'secret_store_id',
 3705        'tags',
 3706        'username',
 3707    ]
 3708
 3709    def __init__(
 3710        self,
 3711        bind_interface=None,
 3712        database=None,
 3713        egress_filter=None,
 3714        healthy=None,
 3715        hostname=None,
 3716        id=None,
 3717        name=None,
 3718        password=None,
 3719        port=None,
 3720        port_override=None,
 3721        secret_store_id=None,
 3722        tags=None,
 3723        username=None,
 3724    ):
 3725        self.bind_interface = bind_interface if bind_interface is not None else ''
 3726        '''
 3727         Bind interface
 3728        '''
 3729        self.database = database if database is not None else ''
 3730        self.egress_filter = egress_filter if egress_filter is not None else ''
 3731        '''
 3732         A filter applied to the routing logic to pin datasource to nodes.
 3733        '''
 3734        self.healthy = healthy if healthy is not None else False
 3735        '''
 3736         True if the datasource is reachable and the credentials are valid.
 3737        '''
 3738        self.hostname = hostname if hostname is not None else ''
 3739        self.id = id if id is not None else ''
 3740        '''
 3741         Unique identifier of the Resource.
 3742        '''
 3743        self.name = name if name is not None else ''
 3744        '''
 3745         Unique human-readable name of the Resource.
 3746        '''
 3747        self.password = password if password is not None else ''
 3748        self.port = port if port is not None else 0
 3749        self.port_override = port_override if port_override is not None else 0
 3750        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3751        '''
 3752         ID of the secret store containing credentials for this resource, if any.
 3753        '''
 3754        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3755        '''
 3756         Tags is a map of key, value pairs.
 3757        '''
 3758        self.username = username if username is not None else ''
 3759
 3760    def __repr__(self):
 3761        return '<sdm.DB2LUW ' + \
 3762            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3763            'database: ' + repr(self.database) + ' ' +\
 3764            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3765            'healthy: ' + repr(self.healthy) + ' ' +\
 3766            'hostname: ' + repr(self.hostname) + ' ' +\
 3767            'id: ' + repr(self.id) + ' ' +\
 3768            'name: ' + repr(self.name) + ' ' +\
 3769            'password: ' + repr(self.password) + ' ' +\
 3770            'port: ' + repr(self.port) + ' ' +\
 3771            'port_override: ' + repr(self.port_override) + ' ' +\
 3772            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3773            'tags: ' + repr(self.tags) + ' ' +\
 3774            'username: ' + repr(self.username) + ' ' +\
 3775            '>'
 3776
 3777    def to_dict(self):
 3778        return {
 3779            'bind_interface': self.bind_interface,
 3780            'database': self.database,
 3781            'egress_filter': self.egress_filter,
 3782            'healthy': self.healthy,
 3783            'hostname': self.hostname,
 3784            'id': self.id,
 3785            'name': self.name,
 3786            'password': self.password,
 3787            'port': self.port,
 3788            'port_override': self.port_override,
 3789            'secret_store_id': self.secret_store_id,
 3790            'tags': self.tags,
 3791            'username': self.username,
 3792        }
 3793
 3794    @classmethod
 3795    def from_dict(cls, d):
 3796        return cls(
 3797            bind_interface=d.get('bind_interface'),
 3798            database=d.get('database'),
 3799            egress_filter=d.get('egress_filter'),
 3800            healthy=d.get('healthy'),
 3801            hostname=d.get('hostname'),
 3802            id=d.get('id'),
 3803            name=d.get('name'),
 3804            password=d.get('password'),
 3805            port=d.get('port'),
 3806            port_override=d.get('port_override'),
 3807            secret_store_id=d.get('secret_store_id'),
 3808            tags=d.get('tags'),
 3809            username=d.get('username'),
 3810        )
 3811
 3812
 3813class DeleteResponseMetadata:
 3814    '''
 3815         DeleteResponseMetadata is reserved for future use.
 3816    '''
 3817    __slots__ = []
 3818
 3819    def __init__(self, ):
 3820        pass
 3821
 3822    def __repr__(self):
 3823        return '<sdm.DeleteResponseMetadata ' + \
 3824            '>'
 3825
 3826    def to_dict(self):
 3827        return {}
 3828
 3829    @classmethod
 3830    def from_dict(cls, d):
 3831        return cls()
 3832
 3833
 3834class DelineaStore:
 3835    '''
 3836    DelineaStore is currently unstable, and its API may change, or it may be removed,
 3837    without a major version bump.
 3838    '''
 3839    __slots__ = [
 3840        'id',
 3841        'name',
 3842        'server_url',
 3843        'tags',
 3844        'tenant_name',
 3845    ]
 3846
 3847    def __init__(
 3848        self,
 3849        id=None,
 3850        name=None,
 3851        server_url=None,
 3852        tags=None,
 3853        tenant_name=None,
 3854    ):
 3855        self.id = id if id is not None else ''
 3856        '''
 3857         Unique identifier of the SecretStore.
 3858        '''
 3859        self.name = name if name is not None else ''
 3860        '''
 3861         Unique human-readable name of the SecretStore.
 3862        '''
 3863        self.server_url = server_url if server_url is not None else ''
 3864        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3865        '''
 3866         Tags is a map of key, value pairs.
 3867        '''
 3868        self.tenant_name = tenant_name if tenant_name is not None else ''
 3869
 3870    def __repr__(self):
 3871        return '<sdm.DelineaStore ' + \
 3872            'id: ' + repr(self.id) + ' ' +\
 3873            'name: ' + repr(self.name) + ' ' +\
 3874            'server_url: ' + repr(self.server_url) + ' ' +\
 3875            'tags: ' + repr(self.tags) + ' ' +\
 3876            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
 3877            '>'
 3878
 3879    def to_dict(self):
 3880        return {
 3881            'id': self.id,
 3882            'name': self.name,
 3883            'server_url': self.server_url,
 3884            'tags': self.tags,
 3885            'tenant_name': self.tenant_name,
 3886        }
 3887
 3888    @classmethod
 3889    def from_dict(cls, d):
 3890        return cls(
 3891            id=d.get('id'),
 3892            name=d.get('name'),
 3893            server_url=d.get('server_url'),
 3894            tags=d.get('tags'),
 3895            tenant_name=d.get('tenant_name'),
 3896        )
 3897
 3898
 3899class DocumentDBHost:
 3900    __slots__ = [
 3901        'auth_database',
 3902        'bind_interface',
 3903        'egress_filter',
 3904        'healthy',
 3905        'hostname',
 3906        'id',
 3907        'name',
 3908        'password',
 3909        'port',
 3910        'port_override',
 3911        'secret_store_id',
 3912        'tags',
 3913        'username',
 3914    ]
 3915
 3916    def __init__(
 3917        self,
 3918        auth_database=None,
 3919        bind_interface=None,
 3920        egress_filter=None,
 3921        healthy=None,
 3922        hostname=None,
 3923        id=None,
 3924        name=None,
 3925        password=None,
 3926        port=None,
 3927        port_override=None,
 3928        secret_store_id=None,
 3929        tags=None,
 3930        username=None,
 3931    ):
 3932        self.auth_database = auth_database if auth_database is not None else ''
 3933        self.bind_interface = bind_interface if bind_interface is not None else ''
 3934        '''
 3935         Bind interface
 3936        '''
 3937        self.egress_filter = egress_filter if egress_filter is not None else ''
 3938        '''
 3939         A filter applied to the routing logic to pin datasource to nodes.
 3940        '''
 3941        self.healthy = healthy if healthy is not None else False
 3942        '''
 3943         True if the datasource is reachable and the credentials are valid.
 3944        '''
 3945        self.hostname = hostname if hostname is not None else ''
 3946        self.id = id if id is not None else ''
 3947        '''
 3948         Unique identifier of the Resource.
 3949        '''
 3950        self.name = name if name is not None else ''
 3951        '''
 3952         Unique human-readable name of the Resource.
 3953        '''
 3954        self.password = password if password is not None else ''
 3955        self.port = port if port is not None else 0
 3956        self.port_override = port_override if port_override is not None else 0
 3957        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3958        '''
 3959         ID of the secret store containing credentials for this resource, if any.
 3960        '''
 3961        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3962        '''
 3963         Tags is a map of key, value pairs.
 3964        '''
 3965        self.username = username if username is not None else ''
 3966
 3967    def __repr__(self):
 3968        return '<sdm.DocumentDBHost ' + \
 3969            'auth_database: ' + repr(self.auth_database) + ' ' +\
 3970            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3971            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3972            'healthy: ' + repr(self.healthy) + ' ' +\
 3973            'hostname: ' + repr(self.hostname) + ' ' +\
 3974            'id: ' + repr(self.id) + ' ' +\
 3975            'name: ' + repr(self.name) + ' ' +\
 3976            'password: ' + repr(self.password) + ' ' +\
 3977            'port: ' + repr(self.port) + ' ' +\
 3978            'port_override: ' + repr(self.port_override) + ' ' +\
 3979            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3980            'tags: ' + repr(self.tags) + ' ' +\
 3981            'username: ' + repr(self.username) + ' ' +\
 3982            '>'
 3983
 3984    def to_dict(self):
 3985        return {
 3986            'auth_database': self.auth_database,
 3987            'bind_interface': self.bind_interface,
 3988            'egress_filter': self.egress_filter,
 3989            'healthy': self.healthy,
 3990            'hostname': self.hostname,
 3991            'id': self.id,
 3992            'name': self.name,
 3993            'password': self.password,
 3994            'port': self.port,
 3995            'port_override': self.port_override,
 3996            'secret_store_id': self.secret_store_id,
 3997            'tags': self.tags,
 3998            'username': self.username,
 3999        }
 4000
 4001    @classmethod
 4002    def from_dict(cls, d):
 4003        return cls(
 4004            auth_database=d.get('auth_database'),
 4005            bind_interface=d.get('bind_interface'),
 4006            egress_filter=d.get('egress_filter'),
 4007            healthy=d.get('healthy'),
 4008            hostname=d.get('hostname'),
 4009            id=d.get('id'),
 4010            name=d.get('name'),
 4011            password=d.get('password'),
 4012            port=d.get('port'),
 4013            port_override=d.get('port_override'),
 4014            secret_store_id=d.get('secret_store_id'),
 4015            tags=d.get('tags'),
 4016            username=d.get('username'),
 4017        )
 4018
 4019
 4020class DocumentDBReplicaSet:
 4021    __slots__ = [
 4022        'auth_database',
 4023        'bind_interface',
 4024        'connect_to_replica',
 4025        'egress_filter',
 4026        'healthy',
 4027        'hostname',
 4028        'id',
 4029        'name',
 4030        'password',
 4031        'port_override',
 4032        'replica_set',
 4033        'secret_store_id',
 4034        'tags',
 4035        'username',
 4036    ]
 4037
 4038    def __init__(
 4039        self,
 4040        auth_database=None,
 4041        bind_interface=None,
 4042        connect_to_replica=None,
 4043        egress_filter=None,
 4044        healthy=None,
 4045        hostname=None,
 4046        id=None,
 4047        name=None,
 4048        password=None,
 4049        port_override=None,
 4050        replica_set=None,
 4051        secret_store_id=None,
 4052        tags=None,
 4053        username=None,
 4054    ):
 4055        self.auth_database = auth_database if auth_database is not None else ''
 4056        self.bind_interface = bind_interface if bind_interface is not None else ''
 4057        '''
 4058         Bind interface
 4059        '''
 4060        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4061        self.egress_filter = egress_filter if egress_filter is not None else ''
 4062        '''
 4063         A filter applied to the routing logic to pin datasource to nodes.
 4064        '''
 4065        self.healthy = healthy if healthy is not None else False
 4066        '''
 4067         True if the datasource is reachable and the credentials are valid.
 4068        '''
 4069        self.hostname = hostname if hostname is not None else ''
 4070        '''
 4071         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4072        '''
 4073        self.id = id if id is not None else ''
 4074        '''
 4075         Unique identifier of the Resource.
 4076        '''
 4077        self.name = name if name is not None else ''
 4078        '''
 4079         Unique human-readable name of the Resource.
 4080        '''
 4081        self.password = password if password is not None else ''
 4082        self.port_override = port_override if port_override is not None else 0
 4083        self.replica_set = replica_set if replica_set is not None else ''
 4084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4085        '''
 4086         ID of the secret store containing credentials for this resource, if any.
 4087        '''
 4088        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4089        '''
 4090         Tags is a map of key, value pairs.
 4091        '''
 4092        self.username = username if username is not None else ''
 4093
 4094    def __repr__(self):
 4095        return '<sdm.DocumentDBReplicaSet ' + \
 4096            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4097            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4098            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4099            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4100            'healthy: ' + repr(self.healthy) + ' ' +\
 4101            'hostname: ' + repr(self.hostname) + ' ' +\
 4102            'id: ' + repr(self.id) + ' ' +\
 4103            'name: ' + repr(self.name) + ' ' +\
 4104            'password: ' + repr(self.password) + ' ' +\
 4105            'port_override: ' + repr(self.port_override) + ' ' +\
 4106            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4107            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4108            'tags: ' + repr(self.tags) + ' ' +\
 4109            'username: ' + repr(self.username) + ' ' +\
 4110            '>'
 4111
 4112    def to_dict(self):
 4113        return {
 4114            'auth_database': self.auth_database,
 4115            'bind_interface': self.bind_interface,
 4116            'connect_to_replica': self.connect_to_replica,
 4117            'egress_filter': self.egress_filter,
 4118            'healthy': self.healthy,
 4119            'hostname': self.hostname,
 4120            'id': self.id,
 4121            'name': self.name,
 4122            'password': self.password,
 4123            'port_override': self.port_override,
 4124            'replica_set': self.replica_set,
 4125            'secret_store_id': self.secret_store_id,
 4126            'tags': self.tags,
 4127            'username': self.username,
 4128        }
 4129
 4130    @classmethod
 4131    def from_dict(cls, d):
 4132        return cls(
 4133            auth_database=d.get('auth_database'),
 4134            bind_interface=d.get('bind_interface'),
 4135            connect_to_replica=d.get('connect_to_replica'),
 4136            egress_filter=d.get('egress_filter'),
 4137            healthy=d.get('healthy'),
 4138            hostname=d.get('hostname'),
 4139            id=d.get('id'),
 4140            name=d.get('name'),
 4141            password=d.get('password'),
 4142            port_override=d.get('port_override'),
 4143            replica_set=d.get('replica_set'),
 4144            secret_store_id=d.get('secret_store_id'),
 4145            tags=d.get('tags'),
 4146            username=d.get('username'),
 4147        )
 4148
 4149
 4150class Druid:
 4151    __slots__ = [
 4152        'bind_interface',
 4153        'egress_filter',
 4154        'healthy',
 4155        'hostname',
 4156        'id',
 4157        'name',
 4158        'password',
 4159        'port',
 4160        'port_override',
 4161        'secret_store_id',
 4162        'tags',
 4163        'username',
 4164    ]
 4165
 4166    def __init__(
 4167        self,
 4168        bind_interface=None,
 4169        egress_filter=None,
 4170        healthy=None,
 4171        hostname=None,
 4172        id=None,
 4173        name=None,
 4174        password=None,
 4175        port=None,
 4176        port_override=None,
 4177        secret_store_id=None,
 4178        tags=None,
 4179        username=None,
 4180    ):
 4181        self.bind_interface = bind_interface if bind_interface is not None else ''
 4182        '''
 4183         Bind interface
 4184        '''
 4185        self.egress_filter = egress_filter if egress_filter is not None else ''
 4186        '''
 4187         A filter applied to the routing logic to pin datasource to nodes.
 4188        '''
 4189        self.healthy = healthy if healthy is not None else False
 4190        '''
 4191         True if the datasource is reachable and the credentials are valid.
 4192        '''
 4193        self.hostname = hostname if hostname is not None else ''
 4194        self.id = id if id is not None else ''
 4195        '''
 4196         Unique identifier of the Resource.
 4197        '''
 4198        self.name = name if name is not None else ''
 4199        '''
 4200         Unique human-readable name of the Resource.
 4201        '''
 4202        self.password = password if password is not None else ''
 4203        self.port = port if port is not None else 0
 4204        self.port_override = port_override if port_override is not None else 0
 4205        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4206        '''
 4207         ID of the secret store containing credentials for this resource, if any.
 4208        '''
 4209        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4210        '''
 4211         Tags is a map of key, value pairs.
 4212        '''
 4213        self.username = username if username is not None else ''
 4214
 4215    def __repr__(self):
 4216        return '<sdm.Druid ' + \
 4217            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4218            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4219            'healthy: ' + repr(self.healthy) + ' ' +\
 4220            'hostname: ' + repr(self.hostname) + ' ' +\
 4221            'id: ' + repr(self.id) + ' ' +\
 4222            'name: ' + repr(self.name) + ' ' +\
 4223            'password: ' + repr(self.password) + ' ' +\
 4224            'port: ' + repr(self.port) + ' ' +\
 4225            'port_override: ' + repr(self.port_override) + ' ' +\
 4226            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4227            'tags: ' + repr(self.tags) + ' ' +\
 4228            'username: ' + repr(self.username) + ' ' +\
 4229            '>'
 4230
 4231    def to_dict(self):
 4232        return {
 4233            'bind_interface': self.bind_interface,
 4234            'egress_filter': self.egress_filter,
 4235            'healthy': self.healthy,
 4236            'hostname': self.hostname,
 4237            'id': self.id,
 4238            'name': self.name,
 4239            'password': self.password,
 4240            'port': self.port,
 4241            'port_override': self.port_override,
 4242            'secret_store_id': self.secret_store_id,
 4243            'tags': self.tags,
 4244            'username': self.username,
 4245        }
 4246
 4247    @classmethod
 4248    def from_dict(cls, d):
 4249        return cls(
 4250            bind_interface=d.get('bind_interface'),
 4251            egress_filter=d.get('egress_filter'),
 4252            healthy=d.get('healthy'),
 4253            hostname=d.get('hostname'),
 4254            id=d.get('id'),
 4255            name=d.get('name'),
 4256            password=d.get('password'),
 4257            port=d.get('port'),
 4258            port_override=d.get('port_override'),
 4259            secret_store_id=d.get('secret_store_id'),
 4260            tags=d.get('tags'),
 4261            username=d.get('username'),
 4262        )
 4263
 4264
 4265class DynamoDB:
 4266    __slots__ = [
 4267        'access_key',
 4268        'bind_interface',
 4269        'egress_filter',
 4270        'endpoint',
 4271        'healthy',
 4272        'id',
 4273        'name',
 4274        'port_override',
 4275        'region',
 4276        'role_arn',
 4277        'role_external_id',
 4278        'secret_access_key',
 4279        'secret_store_id',
 4280        'tags',
 4281    ]
 4282
 4283    def __init__(
 4284        self,
 4285        access_key=None,
 4286        bind_interface=None,
 4287        egress_filter=None,
 4288        endpoint=None,
 4289        healthy=None,
 4290        id=None,
 4291        name=None,
 4292        port_override=None,
 4293        region=None,
 4294        role_arn=None,
 4295        role_external_id=None,
 4296        secret_access_key=None,
 4297        secret_store_id=None,
 4298        tags=None,
 4299    ):
 4300        self.access_key = access_key if access_key is not None else ''
 4301        self.bind_interface = bind_interface if bind_interface is not None else ''
 4302        '''
 4303         Bind interface
 4304        '''
 4305        self.egress_filter = egress_filter if egress_filter is not None else ''
 4306        '''
 4307         A filter applied to the routing logic to pin datasource to nodes.
 4308        '''
 4309        self.endpoint = endpoint if endpoint is not None else ''
 4310        self.healthy = healthy if healthy is not None else False
 4311        '''
 4312         True if the datasource is reachable and the credentials are valid.
 4313        '''
 4314        self.id = id if id is not None else ''
 4315        '''
 4316         Unique identifier of the Resource.
 4317        '''
 4318        self.name = name if name is not None else ''
 4319        '''
 4320         Unique human-readable name of the Resource.
 4321        '''
 4322        self.port_override = port_override if port_override is not None else 0
 4323        self.region = region if region is not None else ''
 4324        self.role_arn = role_arn if role_arn is not None else ''
 4325        self.role_external_id = role_external_id if role_external_id is not None else ''
 4326        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4327        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4328        '''
 4329         ID of the secret store containing credentials for this resource, if any.
 4330        '''
 4331        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4332        '''
 4333         Tags is a map of key, value pairs.
 4334        '''
 4335
 4336    def __repr__(self):
 4337        return '<sdm.DynamoDB ' + \
 4338            'access_key: ' + repr(self.access_key) + ' ' +\
 4339            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4340            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4341            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4342            'healthy: ' + repr(self.healthy) + ' ' +\
 4343            'id: ' + repr(self.id) + ' ' +\
 4344            'name: ' + repr(self.name) + ' ' +\
 4345            'port_override: ' + repr(self.port_override) + ' ' +\
 4346            'region: ' + repr(self.region) + ' ' +\
 4347            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4348            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4349            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4350            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4351            'tags: ' + repr(self.tags) + ' ' +\
 4352            '>'
 4353
 4354    def to_dict(self):
 4355        return {
 4356            'access_key': self.access_key,
 4357            'bind_interface': self.bind_interface,
 4358            'egress_filter': self.egress_filter,
 4359            'endpoint': self.endpoint,
 4360            'healthy': self.healthy,
 4361            'id': self.id,
 4362            'name': self.name,
 4363            'port_override': self.port_override,
 4364            'region': self.region,
 4365            'role_arn': self.role_arn,
 4366            'role_external_id': self.role_external_id,
 4367            'secret_access_key': self.secret_access_key,
 4368            'secret_store_id': self.secret_store_id,
 4369            'tags': self.tags,
 4370        }
 4371
 4372    @classmethod
 4373    def from_dict(cls, d):
 4374        return cls(
 4375            access_key=d.get('access_key'),
 4376            bind_interface=d.get('bind_interface'),
 4377            egress_filter=d.get('egress_filter'),
 4378            endpoint=d.get('endpoint'),
 4379            healthy=d.get('healthy'),
 4380            id=d.get('id'),
 4381            name=d.get('name'),
 4382            port_override=d.get('port_override'),
 4383            region=d.get('region'),
 4384            role_arn=d.get('role_arn'),
 4385            role_external_id=d.get('role_external_id'),
 4386            secret_access_key=d.get('secret_access_key'),
 4387            secret_store_id=d.get('secret_store_id'),
 4388            tags=d.get('tags'),
 4389        )
 4390
 4391
 4392class Elastic:
 4393    __slots__ = [
 4394        'bind_interface',
 4395        'egress_filter',
 4396        'healthy',
 4397        'hostname',
 4398        'id',
 4399        'name',
 4400        'password',
 4401        'port',
 4402        'port_override',
 4403        'secret_store_id',
 4404        'tags',
 4405        'tls_required',
 4406        'username',
 4407    ]
 4408
 4409    def __init__(
 4410        self,
 4411        bind_interface=None,
 4412        egress_filter=None,
 4413        healthy=None,
 4414        hostname=None,
 4415        id=None,
 4416        name=None,
 4417        password=None,
 4418        port=None,
 4419        port_override=None,
 4420        secret_store_id=None,
 4421        tags=None,
 4422        tls_required=None,
 4423        username=None,
 4424    ):
 4425        self.bind_interface = bind_interface if bind_interface is not None else ''
 4426        '''
 4427         Bind interface
 4428        '''
 4429        self.egress_filter = egress_filter if egress_filter is not None else ''
 4430        '''
 4431         A filter applied to the routing logic to pin datasource to nodes.
 4432        '''
 4433        self.healthy = healthy if healthy is not None else False
 4434        '''
 4435         True if the datasource is reachable and the credentials are valid.
 4436        '''
 4437        self.hostname = hostname if hostname is not None else ''
 4438        self.id = id if id is not None else ''
 4439        '''
 4440         Unique identifier of the Resource.
 4441        '''
 4442        self.name = name if name is not None else ''
 4443        '''
 4444         Unique human-readable name of the Resource.
 4445        '''
 4446        self.password = password if password is not None else ''
 4447        self.port = port if port is not None else 0
 4448        self.port_override = port_override if port_override is not None else 0
 4449        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4450        '''
 4451         ID of the secret store containing credentials for this resource, if any.
 4452        '''
 4453        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4454        '''
 4455         Tags is a map of key, value pairs.
 4456        '''
 4457        self.tls_required = tls_required if tls_required is not None else False
 4458        self.username = username if username is not None else ''
 4459
 4460    def __repr__(self):
 4461        return '<sdm.Elastic ' + \
 4462            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4463            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4464            'healthy: ' + repr(self.healthy) + ' ' +\
 4465            'hostname: ' + repr(self.hostname) + ' ' +\
 4466            'id: ' + repr(self.id) + ' ' +\
 4467            'name: ' + repr(self.name) + ' ' +\
 4468            'password: ' + repr(self.password) + ' ' +\
 4469            'port: ' + repr(self.port) + ' ' +\
 4470            'port_override: ' + repr(self.port_override) + ' ' +\
 4471            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4472            'tags: ' + repr(self.tags) + ' ' +\
 4473            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4474            'username: ' + repr(self.username) + ' ' +\
 4475            '>'
 4476
 4477    def to_dict(self):
 4478        return {
 4479            'bind_interface': self.bind_interface,
 4480            'egress_filter': self.egress_filter,
 4481            'healthy': self.healthy,
 4482            'hostname': self.hostname,
 4483            'id': self.id,
 4484            'name': self.name,
 4485            'password': self.password,
 4486            'port': self.port,
 4487            'port_override': self.port_override,
 4488            'secret_store_id': self.secret_store_id,
 4489            'tags': self.tags,
 4490            'tls_required': self.tls_required,
 4491            'username': self.username,
 4492        }
 4493
 4494    @classmethod
 4495    def from_dict(cls, d):
 4496        return cls(
 4497            bind_interface=d.get('bind_interface'),
 4498            egress_filter=d.get('egress_filter'),
 4499            healthy=d.get('healthy'),
 4500            hostname=d.get('hostname'),
 4501            id=d.get('id'),
 4502            name=d.get('name'),
 4503            password=d.get('password'),
 4504            port=d.get('port'),
 4505            port_override=d.get('port_override'),
 4506            secret_store_id=d.get('secret_store_id'),
 4507            tags=d.get('tags'),
 4508            tls_required=d.get('tls_required'),
 4509            username=d.get('username'),
 4510        )
 4511
 4512
 4513class ElasticacheRedis:
 4514    __slots__ = [
 4515        'bind_interface',
 4516        'egress_filter',
 4517        'healthy',
 4518        'hostname',
 4519        'id',
 4520        'name',
 4521        'password',
 4522        'port',
 4523        'port_override',
 4524        'secret_store_id',
 4525        'tags',
 4526        'tls_required',
 4527    ]
 4528
 4529    def __init__(
 4530        self,
 4531        bind_interface=None,
 4532        egress_filter=None,
 4533        healthy=None,
 4534        hostname=None,
 4535        id=None,
 4536        name=None,
 4537        password=None,
 4538        port=None,
 4539        port_override=None,
 4540        secret_store_id=None,
 4541        tags=None,
 4542        tls_required=None,
 4543    ):
 4544        self.bind_interface = bind_interface if bind_interface is not None else ''
 4545        '''
 4546         Bind interface
 4547        '''
 4548        self.egress_filter = egress_filter if egress_filter is not None else ''
 4549        '''
 4550         A filter applied to the routing logic to pin datasource to nodes.
 4551        '''
 4552        self.healthy = healthy if healthy is not None else False
 4553        '''
 4554         True if the datasource is reachable and the credentials are valid.
 4555        '''
 4556        self.hostname = hostname if hostname is not None else ''
 4557        self.id = id if id is not None else ''
 4558        '''
 4559         Unique identifier of the Resource.
 4560        '''
 4561        self.name = name if name is not None else ''
 4562        '''
 4563         Unique human-readable name of the Resource.
 4564        '''
 4565        self.password = password if password is not None else ''
 4566        self.port = port if port is not None else 0
 4567        self.port_override = port_override if port_override is not None else 0
 4568        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4569        '''
 4570         ID of the secret store containing credentials for this resource, if any.
 4571        '''
 4572        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4573        '''
 4574         Tags is a map of key, value pairs.
 4575        '''
 4576        self.tls_required = tls_required if tls_required is not None else False
 4577
 4578    def __repr__(self):
 4579        return '<sdm.ElasticacheRedis ' + \
 4580            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4581            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4582            'healthy: ' + repr(self.healthy) + ' ' +\
 4583            'hostname: ' + repr(self.hostname) + ' ' +\
 4584            'id: ' + repr(self.id) + ' ' +\
 4585            'name: ' + repr(self.name) + ' ' +\
 4586            'password: ' + repr(self.password) + ' ' +\
 4587            'port: ' + repr(self.port) + ' ' +\
 4588            'port_override: ' + repr(self.port_override) + ' ' +\
 4589            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4590            'tags: ' + repr(self.tags) + ' ' +\
 4591            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4592            '>'
 4593
 4594    def to_dict(self):
 4595        return {
 4596            'bind_interface': self.bind_interface,
 4597            'egress_filter': self.egress_filter,
 4598            'healthy': self.healthy,
 4599            'hostname': self.hostname,
 4600            'id': self.id,
 4601            'name': self.name,
 4602            'password': self.password,
 4603            'port': self.port,
 4604            'port_override': self.port_override,
 4605            'secret_store_id': self.secret_store_id,
 4606            'tags': self.tags,
 4607            'tls_required': self.tls_required,
 4608        }
 4609
 4610    @classmethod
 4611    def from_dict(cls, d):
 4612        return cls(
 4613            bind_interface=d.get('bind_interface'),
 4614            egress_filter=d.get('egress_filter'),
 4615            healthy=d.get('healthy'),
 4616            hostname=d.get('hostname'),
 4617            id=d.get('id'),
 4618            name=d.get('name'),
 4619            password=d.get('password'),
 4620            port=d.get('port'),
 4621            port_override=d.get('port_override'),
 4622            secret_store_id=d.get('secret_store_id'),
 4623            tags=d.get('tags'),
 4624            tls_required=d.get('tls_required'),
 4625        )
 4626
 4627
 4628class GCP:
 4629    __slots__ = [
 4630        'bind_interface',
 4631        'egress_filter',
 4632        'healthy',
 4633        'id',
 4634        'keyfile',
 4635        'name',
 4636        'scopes',
 4637        'secret_store_id',
 4638        'tags',
 4639    ]
 4640
 4641    def __init__(
 4642        self,
 4643        bind_interface=None,
 4644        egress_filter=None,
 4645        healthy=None,
 4646        id=None,
 4647        keyfile=None,
 4648        name=None,
 4649        scopes=None,
 4650        secret_store_id=None,
 4651        tags=None,
 4652    ):
 4653        self.bind_interface = bind_interface if bind_interface is not None else ''
 4654        '''
 4655         Bind interface
 4656        '''
 4657        self.egress_filter = egress_filter if egress_filter is not None else ''
 4658        '''
 4659         A filter applied to the routing logic to pin datasource to nodes.
 4660        '''
 4661        self.healthy = healthy if healthy is not None else False
 4662        '''
 4663         True if the datasource is reachable and the credentials are valid.
 4664        '''
 4665        self.id = id if id is not None else ''
 4666        '''
 4667         Unique identifier of the Resource.
 4668        '''
 4669        self.keyfile = keyfile if keyfile is not None else ''
 4670        self.name = name if name is not None else ''
 4671        '''
 4672         Unique human-readable name of the Resource.
 4673        '''
 4674        self.scopes = scopes if scopes is not None else ''
 4675        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4676        '''
 4677         ID of the secret store containing credentials for this resource, if any.
 4678        '''
 4679        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4680        '''
 4681         Tags is a map of key, value pairs.
 4682        '''
 4683
 4684    def __repr__(self):
 4685        return '<sdm.GCP ' + \
 4686            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4687            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4688            'healthy: ' + repr(self.healthy) + ' ' +\
 4689            'id: ' + repr(self.id) + ' ' +\
 4690            'keyfile: ' + repr(self.keyfile) + ' ' +\
 4691            'name: ' + repr(self.name) + ' ' +\
 4692            'scopes: ' + repr(self.scopes) + ' ' +\
 4693            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4694            'tags: ' + repr(self.tags) + ' ' +\
 4695            '>'
 4696
 4697    def to_dict(self):
 4698        return {
 4699            'bind_interface': self.bind_interface,
 4700            'egress_filter': self.egress_filter,
 4701            'healthy': self.healthy,
 4702            'id': self.id,
 4703            'keyfile': self.keyfile,
 4704            'name': self.name,
 4705            'scopes': self.scopes,
 4706            'secret_store_id': self.secret_store_id,
 4707            'tags': self.tags,
 4708        }
 4709
 4710    @classmethod
 4711    def from_dict(cls, d):
 4712        return cls(
 4713            bind_interface=d.get('bind_interface'),
 4714            egress_filter=d.get('egress_filter'),
 4715            healthy=d.get('healthy'),
 4716            id=d.get('id'),
 4717            keyfile=d.get('keyfile'),
 4718            name=d.get('name'),
 4719            scopes=d.get('scopes'),
 4720            secret_store_id=d.get('secret_store_id'),
 4721            tags=d.get('tags'),
 4722        )
 4723
 4724
 4725class GCPStore:
 4726    __slots__ = [
 4727        'id',
 4728        'name',
 4729        'projectid',
 4730        'tags',
 4731    ]
 4732
 4733    def __init__(
 4734        self,
 4735        id=None,
 4736        name=None,
 4737        projectid=None,
 4738        tags=None,
 4739    ):
 4740        self.id = id if id is not None else ''
 4741        '''
 4742         Unique identifier of the SecretStore.
 4743        '''
 4744        self.name = name if name is not None else ''
 4745        '''
 4746         Unique human-readable name of the SecretStore.
 4747        '''
 4748        self.projectid = projectid if projectid is not None else ''
 4749        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4750        '''
 4751         Tags is a map of key, value pairs.
 4752        '''
 4753
 4754    def __repr__(self):
 4755        return '<sdm.GCPStore ' + \
 4756            'id: ' + repr(self.id) + ' ' +\
 4757            'name: ' + repr(self.name) + ' ' +\
 4758            'projectid: ' + repr(self.projectid) + ' ' +\
 4759            'tags: ' + repr(self.tags) + ' ' +\
 4760            '>'
 4761
 4762    def to_dict(self):
 4763        return {
 4764            'id': self.id,
 4765            'name': self.name,
 4766            'projectid': self.projectid,
 4767            'tags': self.tags,
 4768        }
 4769
 4770    @classmethod
 4771    def from_dict(cls, d):
 4772        return cls(
 4773            id=d.get('id'),
 4774            name=d.get('name'),
 4775            projectid=d.get('projectid'),
 4776            tags=d.get('tags'),
 4777        )
 4778
 4779
 4780class Gateway:
 4781    '''
 4782         Gateway represents a StrongDM CLI installation running in gateway mode.
 4783    '''
 4784    __slots__ = [
 4785        'bind_address',
 4786        'gateway_filter',
 4787        'id',
 4788        'listen_address',
 4789        'name',
 4790        'state',
 4791        'tags',
 4792    ]
 4793
 4794    def __init__(
 4795        self,
 4796        bind_address=None,
 4797        gateway_filter=None,
 4798        id=None,
 4799        listen_address=None,
 4800        name=None,
 4801        state=None,
 4802        tags=None,
 4803    ):
 4804        self.bind_address = bind_address if bind_address is not None else ''
 4805        '''
 4806         The hostname/port tuple which the gateway daemon will bind to.
 4807         If not provided on create, set to "0.0.0.0:listen_address_port".
 4808        '''
 4809        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 4810        '''
 4811         GatewayFilter can be used to restrict the peering between relays and
 4812         gateways.
 4813        '''
 4814        self.id = id if id is not None else ''
 4815        '''
 4816         Unique identifier of the Gateway.
 4817        '''
 4818        self.listen_address = listen_address if listen_address is not None else ''
 4819        '''
 4820         The public hostname/port tuple at which the gateway will be accessible to clients.
 4821        '''
 4822        self.name = name if name is not None else ''
 4823        '''
 4824         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 4825        '''
 4826        self.state = state if state is not None else ''
 4827        '''
 4828         The current state of the gateway. One of: "new", "verifying_restart",
 4829         "restarting", "started", "stopped", "dead", "unknown"
 4830        '''
 4831        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4832        '''
 4833         Tags is a map of key, value pairs.
 4834        '''
 4835
 4836    def __repr__(self):
 4837        return '<sdm.Gateway ' + \
 4838            'bind_address: ' + repr(self.bind_address) + ' ' +\
 4839            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 4840            'id: ' + repr(self.id) + ' ' +\
 4841            'listen_address: ' + repr(self.listen_address) + ' ' +\
 4842            'name: ' + repr(self.name) + ' ' +\
 4843            'state: ' + repr(self.state) + ' ' +\
 4844            'tags: ' + repr(self.tags) + ' ' +\
 4845            '>'
 4846
 4847    def to_dict(self):
 4848        return {
 4849            'bind_address': self.bind_address,
 4850            'gateway_filter': self.gateway_filter,
 4851            'id': self.id,
 4852            'listen_address': self.listen_address,
 4853            'name': self.name,
 4854            'state': self.state,
 4855            'tags': self.tags,
 4856        }
 4857
 4858    @classmethod
 4859    def from_dict(cls, d):
 4860        return cls(
 4861            bind_address=d.get('bind_address'),
 4862            gateway_filter=d.get('gateway_filter'),
 4863            id=d.get('id'),
 4864            listen_address=d.get('listen_address'),
 4865            name=d.get('name'),
 4866            state=d.get('state'),
 4867            tags=d.get('tags'),
 4868        )
 4869
 4870
 4871class GetResponseMetadata:
 4872    '''
 4873         GetResponseMetadata is reserved for future use.
 4874    '''
 4875    __slots__ = []
 4876
 4877    def __init__(self, ):
 4878        pass
 4879
 4880    def __repr__(self):
 4881        return '<sdm.GetResponseMetadata ' + \
 4882            '>'
 4883
 4884    def to_dict(self):
 4885        return {}
 4886
 4887    @classmethod
 4888    def from_dict(cls, d):
 4889        return cls()
 4890
 4891
 4892class GoogleGKE:
 4893    __slots__ = [
 4894        'bind_interface',
 4895        'certificate_authority',
 4896        'egress_filter',
 4897        'endpoint',
 4898        'healthcheck_namespace',
 4899        'healthy',
 4900        'id',
 4901        'name',
 4902        'remote_identity_group_id',
 4903        'remote_identity_healthcheck_username',
 4904        'secret_store_id',
 4905        'service_account_key',
 4906        'tags',
 4907    ]
 4908
 4909    def __init__(
 4910        self,
 4911        bind_interface=None,
 4912        certificate_authority=None,
 4913        egress_filter=None,
 4914        endpoint=None,
 4915        healthcheck_namespace=None,
 4916        healthy=None,
 4917        id=None,
 4918        name=None,
 4919        remote_identity_group_id=None,
 4920        remote_identity_healthcheck_username=None,
 4921        secret_store_id=None,
 4922        service_account_key=None,
 4923        tags=None,
 4924    ):
 4925        self.bind_interface = bind_interface if bind_interface is not None else ''
 4926        '''
 4927         Bind interface
 4928        '''
 4929        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 4930        self.egress_filter = egress_filter if egress_filter is not None else ''
 4931        '''
 4932         A filter applied to the routing logic to pin datasource to nodes.
 4933        '''
 4934        self.endpoint = endpoint if endpoint is not None else ''
 4935        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 4936        '''
 4937         The path used to check the health of your connection.  Defaults to `default`.
 4938        '''
 4939        self.healthy = healthy if healthy is not None else False
 4940        '''
 4941         True if the datasource is reachable and the credentials are valid.
 4942        '''
 4943        self.id = id if id is not None else ''
 4944        '''
 4945         Unique identifier of the Resource.
 4946        '''
 4947        self.name = name if name is not None else ''
 4948        '''
 4949         Unique human-readable name of the Resource.
 4950        '''
 4951        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 4952        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 4953        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4954        '''
 4955         ID of the secret store containing credentials for this resource, if any.
 4956        '''
 4957        self.service_account_key = service_account_key if service_account_key is not None else ''
 4958        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4959        '''
 4960         Tags is a map of key, value pairs.
 4961        '''
 4962
 4963    def __repr__(self):
 4964        return '<sdm.GoogleGKE ' + \
 4965            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4966            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 4967            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4968            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4969            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 4970            'healthy: ' + repr(self.healthy) + ' ' +\
 4971            'id: ' + repr(self.id) + ' ' +\
 4972            'name: ' + repr(self.name) + ' ' +\
 4973            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 4974            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 4975            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4976            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 4977            'tags: ' + repr(self.tags) + ' ' +\
 4978            '>'
 4979
 4980    def to_dict(self):
 4981        return {
 4982            'bind_interface': self.bind_interface,
 4983            'certificate_authority': self.certificate_authority,
 4984            'egress_filter': self.egress_filter,
 4985            'endpoint': self.endpoint,
 4986            'healthcheck_namespace': self.healthcheck_namespace,
 4987            'healthy': self.healthy,
 4988            'id': self.id,
 4989            'name': self.name,
 4990            'remote_identity_group_id': self.remote_identity_group_id,
 4991            'remote_identity_healthcheck_username':
 4992            self.remote_identity_healthcheck_username,
 4993            'secret_store_id': self.secret_store_id,
 4994            'service_account_key': self.service_account_key,
 4995            'tags': self.tags,
 4996        }
 4997
 4998    @classmethod
 4999    def from_dict(cls, d):
 5000        return cls(
 5001            bind_interface=d.get('bind_interface'),
 5002            certificate_authority=d.get('certificate_authority'),
 5003            egress_filter=d.get('egress_filter'),
 5004            endpoint=d.get('endpoint'),
 5005            healthcheck_namespace=d.get('healthcheck_namespace'),
 5006            healthy=d.get('healthy'),
 5007            id=d.get('id'),
 5008            name=d.get('name'),
 5009            remote_identity_group_id=d.get('remote_identity_group_id'),
 5010            remote_identity_healthcheck_username=d.get(
 5011                'remote_identity_healthcheck_username'),
 5012            secret_store_id=d.get('secret_store_id'),
 5013            service_account_key=d.get('service_account_key'),
 5014            tags=d.get('tags'),
 5015        )
 5016
 5017
 5018class GoogleGKEUserImpersonation:
 5019    __slots__ = [
 5020        'bind_interface',
 5021        'certificate_authority',
 5022        'egress_filter',
 5023        'endpoint',
 5024        'healthcheck_namespace',
 5025        'healthy',
 5026        'id',
 5027        'name',
 5028        'secret_store_id',
 5029        'service_account_key',
 5030        'tags',
 5031    ]
 5032
 5033    def __init__(
 5034        self,
 5035        bind_interface=None,
 5036        certificate_authority=None,
 5037        egress_filter=None,
 5038        endpoint=None,
 5039        healthcheck_namespace=None,
 5040        healthy=None,
 5041        id=None,
 5042        name=None,
 5043        secret_store_id=None,
 5044        service_account_key=None,
 5045        tags=None,
 5046    ):
 5047        self.bind_interface = bind_interface if bind_interface is not None else ''
 5048        '''
 5049         Bind interface
 5050        '''
 5051        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5052        self.egress_filter = egress_filter if egress_filter is not None else ''
 5053        '''
 5054         A filter applied to the routing logic to pin datasource to nodes.
 5055        '''
 5056        self.endpoint = endpoint if endpoint is not None else ''
 5057        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5058        '''
 5059         The path used to check the health of your connection.  Defaults to `default`.
 5060        '''
 5061        self.healthy = healthy if healthy is not None else False
 5062        '''
 5063         True if the datasource is reachable and the credentials are valid.
 5064        '''
 5065        self.id = id if id is not None else ''
 5066        '''
 5067         Unique identifier of the Resource.
 5068        '''
 5069        self.name = name if name is not None else ''
 5070        '''
 5071         Unique human-readable name of the Resource.
 5072        '''
 5073        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5074        '''
 5075         ID of the secret store containing credentials for this resource, if any.
 5076        '''
 5077        self.service_account_key = service_account_key if service_account_key is not None else ''
 5078        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5079        '''
 5080         Tags is a map of key, value pairs.
 5081        '''
 5082
 5083    def __repr__(self):
 5084        return '<sdm.GoogleGKEUserImpersonation ' + \
 5085            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5086            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5087            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5088            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5089            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5090            'healthy: ' + repr(self.healthy) + ' ' +\
 5091            'id: ' + repr(self.id) + ' ' +\
 5092            'name: ' + repr(self.name) + ' ' +\
 5093            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5094            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5095            'tags: ' + repr(self.tags) + ' ' +\
 5096            '>'
 5097
 5098    def to_dict(self):
 5099        return {
 5100            'bind_interface': self.bind_interface,
 5101            'certificate_authority': self.certificate_authority,
 5102            'egress_filter': self.egress_filter,
 5103            'endpoint': self.endpoint,
 5104            'healthcheck_namespace': self.healthcheck_namespace,
 5105            'healthy': self.healthy,
 5106            'id': self.id,
 5107            'name': self.name,
 5108            'secret_store_id': self.secret_store_id,
 5109            'service_account_key': self.service_account_key,
 5110            'tags': self.tags,
 5111        }
 5112
 5113    @classmethod
 5114    def from_dict(cls, d):
 5115        return cls(
 5116            bind_interface=d.get('bind_interface'),
 5117            certificate_authority=d.get('certificate_authority'),
 5118            egress_filter=d.get('egress_filter'),
 5119            endpoint=d.get('endpoint'),
 5120            healthcheck_namespace=d.get('healthcheck_namespace'),
 5121            healthy=d.get('healthy'),
 5122            id=d.get('id'),
 5123            name=d.get('name'),
 5124            secret_store_id=d.get('secret_store_id'),
 5125            service_account_key=d.get('service_account_key'),
 5126            tags=d.get('tags'),
 5127        )
 5128
 5129
 5130class Greenplum:
 5131    __slots__ = [
 5132        'bind_interface',
 5133        'database',
 5134        'egress_filter',
 5135        'healthy',
 5136        'hostname',
 5137        'id',
 5138        'name',
 5139        'override_database',
 5140        'password',
 5141        'port',
 5142        'port_override',
 5143        'secret_store_id',
 5144        'tags',
 5145        'username',
 5146    ]
 5147
 5148    def __init__(
 5149        self,
 5150        bind_interface=None,
 5151        database=None,
 5152        egress_filter=None,
 5153        healthy=None,
 5154        hostname=None,
 5155        id=None,
 5156        name=None,
 5157        override_database=None,
 5158        password=None,
 5159        port=None,
 5160        port_override=None,
 5161        secret_store_id=None,
 5162        tags=None,
 5163        username=None,
 5164    ):
 5165        self.bind_interface = bind_interface if bind_interface is not None else ''
 5166        '''
 5167         Bind interface
 5168        '''
 5169        self.database = database if database is not None else ''
 5170        self.egress_filter = egress_filter if egress_filter is not None else ''
 5171        '''
 5172         A filter applied to the routing logic to pin datasource to nodes.
 5173        '''
 5174        self.healthy = healthy if healthy is not None else False
 5175        '''
 5176         True if the datasource is reachable and the credentials are valid.
 5177        '''
 5178        self.hostname = hostname if hostname is not None else ''
 5179        self.id = id if id is not None else ''
 5180        '''
 5181         Unique identifier of the Resource.
 5182        '''
 5183        self.name = name if name is not None else ''
 5184        '''
 5185         Unique human-readable name of the Resource.
 5186        '''
 5187        self.override_database = override_database if override_database is not None else False
 5188        self.password = password if password is not None else ''
 5189        self.port = port if port is not None else 0
 5190        self.port_override = port_override if port_override is not None else 0
 5191        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5192        '''
 5193         ID of the secret store containing credentials for this resource, if any.
 5194        '''
 5195        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5196        '''
 5197         Tags is a map of key, value pairs.
 5198        '''
 5199        self.username = username if username is not None else ''
 5200
 5201    def __repr__(self):
 5202        return '<sdm.Greenplum ' + \
 5203            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5204            'database: ' + repr(self.database) + ' ' +\
 5205            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5206            'healthy: ' + repr(self.healthy) + ' ' +\
 5207            'hostname: ' + repr(self.hostname) + ' ' +\
 5208            'id: ' + repr(self.id) + ' ' +\
 5209            'name: ' + repr(self.name) + ' ' +\
 5210            'override_database: ' + repr(self.override_database) + ' ' +\
 5211            'password: ' + repr(self.password) + ' ' +\
 5212            'port: ' + repr(self.port) + ' ' +\
 5213            'port_override: ' + repr(self.port_override) + ' ' +\
 5214            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5215            'tags: ' + repr(self.tags) + ' ' +\
 5216            'username: ' + repr(self.username) + ' ' +\
 5217            '>'
 5218
 5219    def to_dict(self):
 5220        return {
 5221            'bind_interface': self.bind_interface,
 5222            'database': self.database,
 5223            'egress_filter': self.egress_filter,
 5224            'healthy': self.healthy,
 5225            'hostname': self.hostname,
 5226            'id': self.id,
 5227            'name': self.name,
 5228            'override_database': self.override_database,
 5229            'password': self.password,
 5230            'port': self.port,
 5231            'port_override': self.port_override,
 5232            'secret_store_id': self.secret_store_id,
 5233            'tags': self.tags,
 5234            'username': self.username,
 5235        }
 5236
 5237    @classmethod
 5238    def from_dict(cls, d):
 5239        return cls(
 5240            bind_interface=d.get('bind_interface'),
 5241            database=d.get('database'),
 5242            egress_filter=d.get('egress_filter'),
 5243            healthy=d.get('healthy'),
 5244            hostname=d.get('hostname'),
 5245            id=d.get('id'),
 5246            name=d.get('name'),
 5247            override_database=d.get('override_database'),
 5248            password=d.get('password'),
 5249            port=d.get('port'),
 5250            port_override=d.get('port_override'),
 5251            secret_store_id=d.get('secret_store_id'),
 5252            tags=d.get('tags'),
 5253            username=d.get('username'),
 5254        )
 5255
 5256
 5257class HTTPAuth:
 5258    __slots__ = [
 5259        'auth_header',
 5260        'bind_interface',
 5261        'default_path',
 5262        'egress_filter',
 5263        'headers_blacklist',
 5264        'healthcheck_path',
 5265        'healthy',
 5266        'id',
 5267        'name',
 5268        'secret_store_id',
 5269        'subdomain',
 5270        'tags',
 5271        'url',
 5272    ]
 5273
 5274    def __init__(
 5275        self,
 5276        auth_header=None,
 5277        bind_interface=None,
 5278        default_path=None,
 5279        egress_filter=None,
 5280        headers_blacklist=None,
 5281        healthcheck_path=None,
 5282        healthy=None,
 5283        id=None,
 5284        name=None,
 5285        secret_store_id=None,
 5286        subdomain=None,
 5287        tags=None,
 5288        url=None,
 5289    ):
 5290        self.auth_header = auth_header if auth_header is not None else ''
 5291        self.bind_interface = bind_interface if bind_interface is not None else ''
 5292        '''
 5293         Bind interface
 5294        '''
 5295        self.default_path = default_path if default_path is not None else ''
 5296        self.egress_filter = egress_filter if egress_filter is not None else ''
 5297        '''
 5298         A filter applied to the routing logic to pin datasource to nodes.
 5299        '''
 5300        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5301        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5302        self.healthy = healthy if healthy is not None else False
 5303        '''
 5304         True if the datasource is reachable and the credentials are valid.
 5305        '''
 5306        self.id = id if id is not None else ''
 5307        '''
 5308         Unique identifier of the Resource.
 5309        '''
 5310        self.name = name if name is not None else ''
 5311        '''
 5312         Unique human-readable name of the Resource.
 5313        '''
 5314        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5315        '''
 5316         ID of the secret store containing credentials for this resource, if any.
 5317        '''
 5318        self.subdomain = subdomain if subdomain is not None else ''
 5319        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5320        '''
 5321         Tags is a map of key, value pairs.
 5322        '''
 5323        self.url = url if url is not None else ''
 5324
 5325    def __repr__(self):
 5326        return '<sdm.HTTPAuth ' + \
 5327            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5328            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5329            'default_path: ' + repr(self.default_path) + ' ' +\
 5330            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5331            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5332            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5333            'healthy: ' + repr(self.healthy) + ' ' +\
 5334            'id: ' + repr(self.id) + ' ' +\
 5335            'name: ' + repr(self.name) + ' ' +\
 5336            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5337            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5338            'tags: ' + repr(self.tags) + ' ' +\
 5339            'url: ' + repr(self.url) + ' ' +\
 5340            '>'
 5341
 5342    def to_dict(self):
 5343        return {
 5344            'auth_header': self.auth_header,
 5345            'bind_interface': self.bind_interface,
 5346            'default_path': self.default_path,
 5347            'egress_filter': self.egress_filter,
 5348            'headers_blacklist': self.headers_blacklist,
 5349            'healthcheck_path': self.healthcheck_path,
 5350            'healthy': self.healthy,
 5351            'id': self.id,
 5352            'name': self.name,
 5353            'secret_store_id': self.secret_store_id,
 5354            'subdomain': self.subdomain,
 5355            'tags': self.tags,
 5356            'url': self.url,
 5357        }
 5358
 5359    @classmethod
 5360    def from_dict(cls, d):
 5361        return cls(
 5362            auth_header=d.get('auth_header'),
 5363            bind_interface=d.get('bind_interface'),
 5364            default_path=d.get('default_path'),
 5365            egress_filter=d.get('egress_filter'),
 5366            headers_blacklist=d.get('headers_blacklist'),
 5367            healthcheck_path=d.get('healthcheck_path'),
 5368            healthy=d.get('healthy'),
 5369            id=d.get('id'),
 5370            name=d.get('name'),
 5371            secret_store_id=d.get('secret_store_id'),
 5372            subdomain=d.get('subdomain'),
 5373            tags=d.get('tags'),
 5374            url=d.get('url'),
 5375        )
 5376
 5377
 5378class HTTPBasicAuth:
 5379    __slots__ = [
 5380        'bind_interface',
 5381        'default_path',
 5382        'egress_filter',
 5383        'headers_blacklist',
 5384        'healthcheck_path',
 5385        'healthy',
 5386        'id',
 5387        'name',
 5388        'password',
 5389        'secret_store_id',
 5390        'subdomain',
 5391        'tags',
 5392        'url',
 5393        'username',
 5394    ]
 5395
 5396    def __init__(
 5397        self,
 5398        bind_interface=None,
 5399        default_path=None,
 5400        egress_filter=None,
 5401        headers_blacklist=None,
 5402        healthcheck_path=None,
 5403        healthy=None,
 5404        id=None,
 5405        name=None,
 5406        password=None,
 5407        secret_store_id=None,
 5408        subdomain=None,
 5409        tags=None,
 5410        url=None,
 5411        username=None,
 5412    ):
 5413        self.bind_interface = bind_interface if bind_interface is not None else ''
 5414        '''
 5415         Bind interface
 5416        '''
 5417        self.default_path = default_path if default_path is not None else ''
 5418        self.egress_filter = egress_filter if egress_filter is not None else ''
 5419        '''
 5420         A filter applied to the routing logic to pin datasource to nodes.
 5421        '''
 5422        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5423        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5424        self.healthy = healthy if healthy is not None else False
 5425        '''
 5426         True if the datasource is reachable and the credentials are valid.
 5427        '''
 5428        self.id = id if id is not None else ''
 5429        '''
 5430         Unique identifier of the Resource.
 5431        '''
 5432        self.name = name if name is not None else ''
 5433        '''
 5434         Unique human-readable name of the Resource.
 5435        '''
 5436        self.password = password if password is not None else ''
 5437        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5438        '''
 5439         ID of the secret store containing credentials for this resource, if any.
 5440        '''
 5441        self.subdomain = subdomain if subdomain is not None else ''
 5442        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5443        '''
 5444         Tags is a map of key, value pairs.
 5445        '''
 5446        self.url = url if url is not None else ''
 5447        self.username = username if username is not None else ''
 5448
 5449    def __repr__(self):
 5450        return '<sdm.HTTPBasicAuth ' + \
 5451            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5452            'default_path: ' + repr(self.default_path) + ' ' +\
 5453            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5454            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5455            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5456            'healthy: ' + repr(self.healthy) + ' ' +\
 5457            'id: ' + repr(self.id) + ' ' +\
 5458            'name: ' + repr(self.name) + ' ' +\
 5459            'password: ' + repr(self.password) + ' ' +\
 5460            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5461            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5462            'tags: ' + repr(self.tags) + ' ' +\
 5463            'url: ' + repr(self.url) + ' ' +\
 5464            'username: ' + repr(self.username) + ' ' +\
 5465            '>'
 5466
 5467    def to_dict(self):
 5468        return {
 5469            'bind_interface': self.bind_interface,
 5470            'default_path': self.default_path,
 5471            'egress_filter': self.egress_filter,
 5472            'headers_blacklist': self.headers_blacklist,
 5473            'healthcheck_path': self.healthcheck_path,
 5474            'healthy': self.healthy,
 5475            'id': self.id,
 5476            'name': self.name,
 5477            'password': self.password,
 5478            'secret_store_id': self.secret_store_id,
 5479            'subdomain': self.subdomain,
 5480            'tags': self.tags,
 5481            'url': self.url,
 5482            'username': self.username,
 5483        }
 5484
 5485    @classmethod
 5486    def from_dict(cls, d):
 5487        return cls(
 5488            bind_interface=d.get('bind_interface'),
 5489            default_path=d.get('default_path'),
 5490            egress_filter=d.get('egress_filter'),
 5491            headers_blacklist=d.get('headers_blacklist'),
 5492            healthcheck_path=d.get('healthcheck_path'),
 5493            healthy=d.get('healthy'),
 5494            id=d.get('id'),
 5495            name=d.get('name'),
 5496            password=d.get('password'),
 5497            secret_store_id=d.get('secret_store_id'),
 5498            subdomain=d.get('subdomain'),
 5499            tags=d.get('tags'),
 5500            url=d.get('url'),
 5501            username=d.get('username'),
 5502        )
 5503
 5504
 5505class HTTPNoAuth:
 5506    __slots__ = [
 5507        'bind_interface',
 5508        'default_path',
 5509        'egress_filter',
 5510        'headers_blacklist',
 5511        'healthcheck_path',
 5512        'healthy',
 5513        'id',
 5514        'name',
 5515        'secret_store_id',
 5516        'subdomain',
 5517        'tags',
 5518        'url',
 5519    ]
 5520
 5521    def __init__(
 5522        self,
 5523        bind_interface=None,
 5524        default_path=None,
 5525        egress_filter=None,
 5526        headers_blacklist=None,
 5527        healthcheck_path=None,
 5528        healthy=None,
 5529        id=None,
 5530        name=None,
 5531        secret_store_id=None,
 5532        subdomain=None,
 5533        tags=None,
 5534        url=None,
 5535    ):
 5536        self.bind_interface = bind_interface if bind_interface is not None else ''
 5537        '''
 5538         Bind interface
 5539        '''
 5540        self.default_path = default_path if default_path is not None else ''
 5541        self.egress_filter = egress_filter if egress_filter is not None else ''
 5542        '''
 5543         A filter applied to the routing logic to pin datasource to nodes.
 5544        '''
 5545        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5546        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5547        self.healthy = healthy if healthy is not None else False
 5548        '''
 5549         True if the datasource is reachable and the credentials are valid.
 5550        '''
 5551        self.id = id if id is not None else ''
 5552        '''
 5553         Unique identifier of the Resource.
 5554        '''
 5555        self.name = name if name is not None else ''
 5556        '''
 5557         Unique human-readable name of the Resource.
 5558        '''
 5559        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5560        '''
 5561         ID of the secret store containing credentials for this resource, if any.
 5562        '''
 5563        self.subdomain = subdomain if subdomain is not None else ''
 5564        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5565        '''
 5566         Tags is a map of key, value pairs.
 5567        '''
 5568        self.url = url if url is not None else ''
 5569
 5570    def __repr__(self):
 5571        return '<sdm.HTTPNoAuth ' + \
 5572            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5573            'default_path: ' + repr(self.default_path) + ' ' +\
 5574            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5575            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5576            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5577            'healthy: ' + repr(self.healthy) + ' ' +\
 5578            'id: ' + repr(self.id) + ' ' +\
 5579            'name: ' + repr(self.name) + ' ' +\
 5580            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5581            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5582            'tags: ' + repr(self.tags) + ' ' +\
 5583            'url: ' + repr(self.url) + ' ' +\
 5584            '>'
 5585
 5586    def to_dict(self):
 5587        return {
 5588            'bind_interface': self.bind_interface,
 5589            'default_path': self.default_path,
 5590            'egress_filter': self.egress_filter,
 5591            'headers_blacklist': self.headers_blacklist,
 5592            'healthcheck_path': self.healthcheck_path,
 5593            'healthy': self.healthy,
 5594            'id': self.id,
 5595            'name': self.name,
 5596            'secret_store_id': self.secret_store_id,
 5597            'subdomain': self.subdomain,
 5598            'tags': self.tags,
 5599            'url': self.url,
 5600        }
 5601
 5602    @classmethod
 5603    def from_dict(cls, d):
 5604        return cls(
 5605            bind_interface=d.get('bind_interface'),
 5606            default_path=d.get('default_path'),
 5607            egress_filter=d.get('egress_filter'),
 5608            headers_blacklist=d.get('headers_blacklist'),
 5609            healthcheck_path=d.get('healthcheck_path'),
 5610            healthy=d.get('healthy'),
 5611            id=d.get('id'),
 5612            name=d.get('name'),
 5613            secret_store_id=d.get('secret_store_id'),
 5614            subdomain=d.get('subdomain'),
 5615            tags=d.get('tags'),
 5616            url=d.get('url'),
 5617        )
 5618
 5619
 5620class Kubernetes:
 5621    __slots__ = [
 5622        'bind_interface',
 5623        'certificate_authority',
 5624        'client_certificate',
 5625        'client_key',
 5626        'egress_filter',
 5627        'healthcheck_namespace',
 5628        'healthy',
 5629        'hostname',
 5630        'id',
 5631        'name',
 5632        'port',
 5633        'port_override',
 5634        'remote_identity_group_id',
 5635        'remote_identity_healthcheck_username',
 5636        'secret_store_id',
 5637        'tags',
 5638    ]
 5639
 5640    def __init__(
 5641        self,
 5642        bind_interface=None,
 5643        certificate_authority=None,
 5644        client_certificate=None,
 5645        client_key=None,
 5646        egress_filter=None,
 5647        healthcheck_namespace=None,
 5648        healthy=None,
 5649        hostname=None,
 5650        id=None,
 5651        name=None,
 5652        port=None,
 5653        port_override=None,
 5654        remote_identity_group_id=None,
 5655        remote_identity_healthcheck_username=None,
 5656        secret_store_id=None,
 5657        tags=None,
 5658    ):
 5659        self.bind_interface = bind_interface if bind_interface is not None else ''
 5660        '''
 5661         Bind interface
 5662        '''
 5663        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5664        self.client_certificate = client_certificate if client_certificate is not None else ''
 5665        self.client_key = client_key if client_key is not None else ''
 5666        self.egress_filter = egress_filter if egress_filter is not None else ''
 5667        '''
 5668         A filter applied to the routing logic to pin datasource to nodes.
 5669        '''
 5670        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5671        '''
 5672         The path used to check the health of your connection.  Defaults to `default`.
 5673        '''
 5674        self.healthy = healthy if healthy is not None else False
 5675        '''
 5676         True if the datasource is reachable and the credentials are valid.
 5677        '''
 5678        self.hostname = hostname if hostname is not None else ''
 5679        self.id = id if id is not None else ''
 5680        '''
 5681         Unique identifier of the Resource.
 5682        '''
 5683        self.name = name if name is not None else ''
 5684        '''
 5685         Unique human-readable name of the Resource.
 5686        '''
 5687        self.port = port if port is not None else 0
 5688        self.port_override = port_override if port_override is not None else 0
 5689        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5690        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5691        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5692        '''
 5693         ID of the secret store containing credentials for this resource, if any.
 5694        '''
 5695        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5696        '''
 5697         Tags is a map of key, value pairs.
 5698        '''
 5699
 5700    def __repr__(self):
 5701        return '<sdm.Kubernetes ' + \
 5702            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5703            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5704            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 5705            'client_key: ' + repr(self.client_key) + ' ' +\
 5706            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5707            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5708            'healthy: ' + repr(self.healthy) + ' ' +\
 5709            'hostname: ' + repr(self.hostname) + ' ' +\
 5710            'id: ' + repr(self.id) + ' ' +\
 5711            'name: ' + repr(self.name) + ' ' +\
 5712            'port: ' + repr(self.port) + ' ' +\
 5713            'port_override: ' + repr(self.port_override) + ' ' +\
 5714            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5715            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5716            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5717            'tags: ' + repr(self.tags) + ' ' +\
 5718            '>'
 5719
 5720    def to_dict(self):
 5721        return {
 5722            'bind_interface': self.bind_interface,
 5723            'certificate_authority': self.certificate_authority,
 5724            'client_certificate': self.client_certificate,
 5725            'client_key': self.client_key,
 5726            'egress_filter': self.egress_filter,
 5727            'healthcheck_namespace': self.healthcheck_namespace,
 5728            'healthy': self.healthy,
 5729            'hostname': self.hostname,
 5730            'id': self.id,
 5731            'name': self.name,
 5732            'port': self.port,
 5733            'port_override': self.port_override,
 5734            'remote_identity_group_id': self.remote_identity_group_id,
 5735            'remote_identity_healthcheck_username':
 5736            self.remote_identity_healthcheck_username,
 5737            'secret_store_id': self.secret_store_id,
 5738            'tags': self.tags,
 5739        }
 5740
 5741    @classmethod
 5742    def from_dict(cls, d):
 5743        return cls(
 5744            bind_interface=d.get('bind_interface'),
 5745            certificate_authority=d.get('certificate_authority'),
 5746            client_certificate=d.get('client_certificate'),
 5747            client_key=d.get('client_key'),
 5748            egress_filter=d.get('egress_filter'),
 5749            healthcheck_namespace=d.get('healthcheck_namespace'),
 5750            healthy=d.get('healthy'),
 5751            hostname=d.get('hostname'),
 5752            id=d.get('id'),
 5753            name=d.get('name'),
 5754            port=d.get('port'),
 5755            port_override=d.get('port_override'),
 5756            remote_identity_group_id=d.get('remote_identity_group_id'),
 5757            remote_identity_healthcheck_username=d.get(
 5758                'remote_identity_healthcheck_username'),
 5759            secret_store_id=d.get('secret_store_id'),
 5760            tags=d.get('tags'),
 5761        )
 5762
 5763
 5764class KubernetesBasicAuth:
 5765    __slots__ = [
 5766        'bind_interface',
 5767        'egress_filter',
 5768        'healthcheck_namespace',
 5769        'healthy',
 5770        'hostname',
 5771        'id',
 5772        'name',
 5773        'password',
 5774        'port',
 5775        'port_override',
 5776        'secret_store_id',
 5777        'tags',
 5778        'username',
 5779    ]
 5780
 5781    def __init__(
 5782        self,
 5783        bind_interface=None,
 5784        egress_filter=None,
 5785        healthcheck_namespace=None,
 5786        healthy=None,
 5787        hostname=None,
 5788        id=None,
 5789        name=None,
 5790        password=None,
 5791        port=None,
 5792        port_override=None,
 5793        secret_store_id=None,
 5794        tags=None,
 5795        username=None,
 5796    ):
 5797        self.bind_interface = bind_interface if bind_interface is not None else ''
 5798        '''
 5799         Bind interface
 5800        '''
 5801        self.egress_filter = egress_filter if egress_filter is not None else ''
 5802        '''
 5803         A filter applied to the routing logic to pin datasource to nodes.
 5804        '''
 5805        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5806        '''
 5807         The path used to check the health of your connection.  Defaults to `default`.
 5808        '''
 5809        self.healthy = healthy if healthy is not None else False
 5810        '''
 5811         True if the datasource is reachable and the credentials are valid.
 5812        '''
 5813        self.hostname = hostname if hostname is not None else ''
 5814        self.id = id if id is not None else ''
 5815        '''
 5816         Unique identifier of the Resource.
 5817        '''
 5818        self.name = name if name is not None else ''
 5819        '''
 5820         Unique human-readable name of the Resource.
 5821        '''
 5822        self.password = password if password is not None else ''
 5823        self.port = port if port is not None else 0
 5824        self.port_override = port_override if port_override is not None else 0
 5825        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5826        '''
 5827         ID of the secret store containing credentials for this resource, if any.
 5828        '''
 5829        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5830        '''
 5831         Tags is a map of key, value pairs.
 5832        '''
 5833        self.username = username if username is not None else ''
 5834
 5835    def __repr__(self):
 5836        return '<sdm.KubernetesBasicAuth ' + \
 5837            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5838            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5839            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5840            'healthy: ' + repr(self.healthy) + ' ' +\
 5841            'hostname: ' + repr(self.hostname) + ' ' +\
 5842            'id: ' + repr(self.id) + ' ' +\
 5843            'name: ' + repr(self.name) + ' ' +\
 5844            'password: ' + repr(self.password) + ' ' +\
 5845            'port: ' + repr(self.port) + ' ' +\
 5846            'port_override: ' + repr(self.port_override) + ' ' +\
 5847            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5848            'tags: ' + repr(self.tags) + ' ' +\
 5849            'username: ' + repr(self.username) + ' ' +\
 5850            '>'
 5851
 5852    def to_dict(self):
 5853        return {
 5854            'bind_interface': self.bind_interface,
 5855            'egress_filter': self.egress_filter,
 5856            'healthcheck_namespace': self.healthcheck_namespace,
 5857            'healthy': self.healthy,
 5858            'hostname': self.hostname,
 5859            'id': self.id,
 5860            'name': self.name,
 5861            'password': self.password,
 5862            'port': self.port,
 5863            'port_override': self.port_override,
 5864            'secret_store_id': self.secret_store_id,
 5865            'tags': self.tags,
 5866            'username': self.username,
 5867        }
 5868
 5869    @classmethod
 5870    def from_dict(cls, d):
 5871        return cls(
 5872            bind_interface=d.get('bind_interface'),
 5873            egress_filter=d.get('egress_filter'),
 5874            healthcheck_namespace=d.get('healthcheck_namespace'),
 5875            healthy=d.get('healthy'),
 5876            hostname=d.get('hostname'),
 5877            id=d.get('id'),
 5878            name=d.get('name'),
 5879            password=d.get('password'),
 5880            port=d.get('port'),
 5881            port_override=d.get('port_override'),
 5882            secret_store_id=d.get('secret_store_id'),
 5883            tags=d.get('tags'),
 5884            username=d.get('username'),
 5885        )
 5886
 5887
 5888class KubernetesServiceAccount:
 5889    __slots__ = [
 5890        'bind_interface',
 5891        'egress_filter',
 5892        'healthcheck_namespace',
 5893        'healthy',
 5894        'hostname',
 5895        'id',
 5896        'name',
 5897        'port',
 5898        'port_override',
 5899        'remote_identity_group_id',
 5900        'remote_identity_healthcheck_username',
 5901        'secret_store_id',
 5902        'tags',
 5903        'token',
 5904    ]
 5905
 5906    def __init__(
 5907        self,
 5908        bind_interface=None,
 5909        egress_filter=None,
 5910        healthcheck_namespace=None,
 5911        healthy=None,
 5912        hostname=None,
 5913        id=None,
 5914        name=None,
 5915        port=None,
 5916        port_override=None,
 5917        remote_identity_group_id=None,
 5918        remote_identity_healthcheck_username=None,
 5919        secret_store_id=None,
 5920        tags=None,
 5921        token=None,
 5922    ):
 5923        self.bind_interface = bind_interface if bind_interface is not None else ''
 5924        '''
 5925         Bind interface
 5926        '''
 5927        self.egress_filter = egress_filter if egress_filter is not None else ''
 5928        '''
 5929         A filter applied to the routing logic to pin datasource to nodes.
 5930        '''
 5931        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5932        '''
 5933         The path used to check the health of your connection.  Defaults to `default`.
 5934        '''
 5935        self.healthy = healthy if healthy is not None else False
 5936        '''
 5937         True if the datasource is reachable and the credentials are valid.
 5938        '''
 5939        self.hostname = hostname if hostname is not None else ''
 5940        self.id = id if id is not None else ''
 5941        '''
 5942         Unique identifier of the Resource.
 5943        '''
 5944        self.name = name if name is not None else ''
 5945        '''
 5946         Unique human-readable name of the Resource.
 5947        '''
 5948        self.port = port if port is not None else 0
 5949        self.port_override = port_override if port_override is not None else 0
 5950        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5951        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5952        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5953        '''
 5954         ID of the secret store containing credentials for this resource, if any.
 5955        '''
 5956        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5957        '''
 5958         Tags is a map of key, value pairs.
 5959        '''
 5960        self.token = token if token is not None else ''
 5961
 5962    def __repr__(self):
 5963        return '<sdm.KubernetesServiceAccount ' + \
 5964            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5965            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5966            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5967            'healthy: ' + repr(self.healthy) + ' ' +\
 5968            'hostname: ' + repr(self.hostname) + ' ' +\
 5969            'id: ' + repr(self.id) + ' ' +\
 5970            'name: ' + repr(self.name) + ' ' +\
 5971            'port: ' + repr(self.port) + ' ' +\
 5972            'port_override: ' + repr(self.port_override) + ' ' +\
 5973            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5974            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5975            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5976            'tags: ' + repr(self.tags) + ' ' +\
 5977            'token: ' + repr(self.token) + ' ' +\
 5978            '>'
 5979
 5980    def to_dict(self):
 5981        return {
 5982            'bind_interface': self.bind_interface,
 5983            'egress_filter': self.egress_filter,
 5984            'healthcheck_namespace': self.healthcheck_namespace,
 5985            'healthy': self.healthy,
 5986            'hostname': self.hostname,
 5987            'id': self.id,
 5988            'name': self.name,
 5989            'port': self.port,
 5990            'port_override': self.port_override,
 5991            'remote_identity_group_id': self.remote_identity_group_id,
 5992            'remote_identity_healthcheck_username':
 5993            self.remote_identity_healthcheck_username,
 5994            'secret_store_id': self.secret_store_id,
 5995            'tags': self.tags,
 5996            'token': self.token,
 5997        }
 5998
 5999    @classmethod
 6000    def from_dict(cls, d):
 6001        return cls(
 6002            bind_interface=d.get('bind_interface'),
 6003            egress_filter=d.get('egress_filter'),
 6004            healthcheck_namespace=d.get('healthcheck_namespace'),
 6005            healthy=d.get('healthy'),
 6006            hostname=d.get('hostname'),
 6007            id=d.get('id'),
 6008            name=d.get('name'),
 6009            port=d.get('port'),
 6010            port_override=d.get('port_override'),
 6011            remote_identity_group_id=d.get('remote_identity_group_id'),
 6012            remote_identity_healthcheck_username=d.get(
 6013                'remote_identity_healthcheck_username'),
 6014            secret_store_id=d.get('secret_store_id'),
 6015            tags=d.get('tags'),
 6016            token=d.get('token'),
 6017        )
 6018
 6019
 6020class KubernetesServiceAccountUserImpersonation:
 6021    __slots__ = [
 6022        'bind_interface',
 6023        'egress_filter',
 6024        'healthcheck_namespace',
 6025        'healthy',
 6026        'hostname',
 6027        'id',
 6028        'name',
 6029        'port',
 6030        'port_override',
 6031        'secret_store_id',
 6032        'tags',
 6033        'token',
 6034    ]
 6035
 6036    def __init__(
 6037        self,
 6038        bind_interface=None,
 6039        egress_filter=None,
 6040        healthcheck_namespace=None,
 6041        healthy=None,
 6042        hostname=None,
 6043        id=None,
 6044        name=None,
 6045        port=None,
 6046        port_override=None,
 6047        secret_store_id=None,
 6048        tags=None,
 6049        token=None,
 6050    ):
 6051        self.bind_interface = bind_interface if bind_interface is not None else ''
 6052        '''
 6053         Bind interface
 6054        '''
 6055        self.egress_filter = egress_filter if egress_filter is not None else ''
 6056        '''
 6057         A filter applied to the routing logic to pin datasource to nodes.
 6058        '''
 6059        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6060        '''
 6061         The path used to check the health of your connection.  Defaults to `default`.
 6062        '''
 6063        self.healthy = healthy if healthy is not None else False
 6064        '''
 6065         True if the datasource is reachable and the credentials are valid.
 6066        '''
 6067        self.hostname = hostname if hostname is not None else ''
 6068        self.id = id if id is not None else ''
 6069        '''
 6070         Unique identifier of the Resource.
 6071        '''
 6072        self.name = name if name is not None else ''
 6073        '''
 6074         Unique human-readable name of the Resource.
 6075        '''
 6076        self.port = port if port is not None else 0
 6077        self.port_override = port_override if port_override is not None else 0
 6078        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6079        '''
 6080         ID of the secret store containing credentials for this resource, if any.
 6081        '''
 6082        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6083        '''
 6084         Tags is a map of key, value pairs.
 6085        '''
 6086        self.token = token if token is not None else ''
 6087
 6088    def __repr__(self):
 6089        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6090            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6091            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6092            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6093            'healthy: ' + repr(self.healthy) + ' ' +\
 6094            'hostname: ' + repr(self.hostname) + ' ' +\
 6095            'id: ' + repr(self.id) + ' ' +\
 6096            'name: ' + repr(self.name) + ' ' +\
 6097            'port: ' + repr(self.port) + ' ' +\
 6098            'port_override: ' + repr(self.port_override) + ' ' +\
 6099            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6100            'tags: ' + repr(self.tags) + ' ' +\
 6101            'token: ' + repr(self.token) + ' ' +\
 6102            '>'
 6103
 6104    def to_dict(self):
 6105        return {
 6106            'bind_interface': self.bind_interface,
 6107            'egress_filter': self.egress_filter,
 6108            'healthcheck_namespace': self.healthcheck_namespace,
 6109            'healthy': self.healthy,
 6110            'hostname': self.hostname,
 6111            'id': self.id,
 6112            'name': self.name,
 6113            'port': self.port,
 6114            'port_override': self.port_override,
 6115            'secret_store_id': self.secret_store_id,
 6116            'tags': self.tags,
 6117            'token': self.token,
 6118        }
 6119
 6120    @classmethod
 6121    def from_dict(cls, d):
 6122        return cls(
 6123            bind_interface=d.get('bind_interface'),
 6124            egress_filter=d.get('egress_filter'),
 6125            healthcheck_namespace=d.get('healthcheck_namespace'),
 6126            healthy=d.get('healthy'),
 6127            hostname=d.get('hostname'),
 6128            id=d.get('id'),
 6129            name=d.get('name'),
 6130            port=d.get('port'),
 6131            port_override=d.get('port_override'),
 6132            secret_store_id=d.get('secret_store_id'),
 6133            tags=d.get('tags'),
 6134            token=d.get('token'),
 6135        )
 6136
 6137
 6138class KubernetesUserImpersonation:
 6139    __slots__ = [
 6140        'bind_interface',
 6141        'certificate_authority',
 6142        'client_certificate',
 6143        'client_key',
 6144        'egress_filter',
 6145        'healthcheck_namespace',
 6146        'healthy',
 6147        'hostname',
 6148        'id',
 6149        'name',
 6150        'port',
 6151        'port_override',
 6152        'secret_store_id',
 6153        'tags',
 6154    ]
 6155
 6156    def __init__(
 6157        self,
 6158        bind_interface=None,
 6159        certificate_authority=None,
 6160        client_certificate=None,
 6161        client_key=None,
 6162        egress_filter=None,
 6163        healthcheck_namespace=None,
 6164        healthy=None,
 6165        hostname=None,
 6166        id=None,
 6167        name=None,
 6168        port=None,
 6169        port_override=None,
 6170        secret_store_id=None,
 6171        tags=None,
 6172    ):
 6173        self.bind_interface = bind_interface if bind_interface is not None else ''
 6174        '''
 6175         Bind interface
 6176        '''
 6177        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6178        self.client_certificate = client_certificate if client_certificate is not None else ''
 6179        self.client_key = client_key if client_key is not None else ''
 6180        self.egress_filter = egress_filter if egress_filter is not None else ''
 6181        '''
 6182         A filter applied to the routing logic to pin datasource to nodes.
 6183        '''
 6184        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6185        '''
 6186         The path used to check the health of your connection.  Defaults to `default`.
 6187        '''
 6188        self.healthy = healthy if healthy is not None else False
 6189        '''
 6190         True if the datasource is reachable and the credentials are valid.
 6191        '''
 6192        self.hostname = hostname if hostname is not None else ''
 6193        self.id = id if id is not None else ''
 6194        '''
 6195         Unique identifier of the Resource.
 6196        '''
 6197        self.name = name if name is not None else ''
 6198        '''
 6199         Unique human-readable name of the Resource.
 6200        '''
 6201        self.port = port if port is not None else 0
 6202        self.port_override = port_override if port_override is not None else 0
 6203        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6204        '''
 6205         ID of the secret store containing credentials for this resource, if any.
 6206        '''
 6207        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6208        '''
 6209         Tags is a map of key, value pairs.
 6210        '''
 6211
 6212    def __repr__(self):
 6213        return '<sdm.KubernetesUserImpersonation ' + \
 6214            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6215            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6216            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6217            'client_key: ' + repr(self.client_key) + ' ' +\
 6218            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6219            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6220            'healthy: ' + repr(self.healthy) + ' ' +\
 6221            'hostname: ' + repr(self.hostname) + ' ' +\
 6222            'id: ' + repr(self.id) + ' ' +\
 6223            'name: ' + repr(self.name) + ' ' +\
 6224            'port: ' + repr(self.port) + ' ' +\
 6225            'port_override: ' + repr(self.port_override) + ' ' +\
 6226            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6227            'tags: ' + repr(self.tags) + ' ' +\
 6228            '>'
 6229
 6230    def to_dict(self):
 6231        return {
 6232            'bind_interface': self.bind_interface,
 6233            'certificate_authority': self.certificate_authority,
 6234            'client_certificate': self.client_certificate,
 6235            'client_key': self.client_key,
 6236            'egress_filter': self.egress_filter,
 6237            'healthcheck_namespace': self.healthcheck_namespace,
 6238            'healthy': self.healthy,
 6239            'hostname': self.hostname,
 6240            'id': self.id,
 6241            'name': self.name,
 6242            'port': self.port,
 6243            'port_override': self.port_override,
 6244            'secret_store_id': self.secret_store_id,
 6245            'tags': self.tags,
 6246        }
 6247
 6248    @classmethod
 6249    def from_dict(cls, d):
 6250        return cls(
 6251            bind_interface=d.get('bind_interface'),
 6252            certificate_authority=d.get('certificate_authority'),
 6253            client_certificate=d.get('client_certificate'),
 6254            client_key=d.get('client_key'),
 6255            egress_filter=d.get('egress_filter'),
 6256            healthcheck_namespace=d.get('healthcheck_namespace'),
 6257            healthy=d.get('healthy'),
 6258            hostname=d.get('hostname'),
 6259            id=d.get('id'),
 6260            name=d.get('name'),
 6261            port=d.get('port'),
 6262            port_override=d.get('port_override'),
 6263            secret_store_id=d.get('secret_store_id'),
 6264            tags=d.get('tags'),
 6265        )
 6266
 6267
 6268class MTLSMysql:
 6269    '''
 6270    MTLSMysql is currently unstable, and its API may change, or it may be removed,
 6271    without a major version bump.
 6272    '''
 6273    __slots__ = [
 6274        'bind_interface',
 6275        'certificate_authority',
 6276        'client_certificate',
 6277        'client_key',
 6278        'database',
 6279        'egress_filter',
 6280        'healthy',
 6281        'hostname',
 6282        'id',
 6283        'name',
 6284        'password',
 6285        'port',
 6286        'port_override',
 6287        'secret_store_id',
 6288        'server_name',
 6289        'tags',
 6290        'username',
 6291    ]
 6292
 6293    def __init__(
 6294        self,
 6295        bind_interface=None,
 6296        certificate_authority=None,
 6297        client_certificate=None,
 6298        client_key=None,
 6299        database=None,
 6300        egress_filter=None,
 6301        healthy=None,
 6302        hostname=None,
 6303        id=None,
 6304        name=None,
 6305        password=None,
 6306        port=None,
 6307        port_override=None,
 6308        secret_store_id=None,
 6309        server_name=None,
 6310        tags=None,
 6311        username=None,
 6312    ):
 6313        self.bind_interface = bind_interface if bind_interface is not None else ''
 6314        '''
 6315         Bind interface
 6316        '''
 6317        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6318        self.client_certificate = client_certificate if client_certificate is not None else ''
 6319        self.client_key = client_key if client_key is not None else ''
 6320        self.database = database if database is not None else ''
 6321        self.egress_filter = egress_filter if egress_filter is not None else ''
 6322        '''
 6323         A filter applied to the routing logic to pin datasource to nodes.
 6324        '''
 6325        self.healthy = healthy if healthy is not None else False
 6326        '''
 6327         True if the datasource is reachable and the credentials are valid.
 6328        '''
 6329        self.hostname = hostname if hostname is not None else ''
 6330        self.id = id if id is not None else ''
 6331        '''
 6332         Unique identifier of the Resource.
 6333        '''
 6334        self.name = name if name is not None else ''
 6335        '''
 6336         Unique human-readable name of the Resource.
 6337        '''
 6338        self.password = password if password is not None else ''
 6339        self.port = port if port is not None else 0
 6340        self.port_override = port_override if port_override is not None else 0
 6341        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6342        '''
 6343         ID of the secret store containing credentials for this resource, if any.
 6344        '''
 6345        self.server_name = server_name if server_name is not None else ''
 6346        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6347        '''
 6348         Tags is a map of key, value pairs.
 6349        '''
 6350        self.username = username if username is not None else ''
 6351
 6352    def __repr__(self):
 6353        return '<sdm.MTLSMysql ' + \
 6354            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6355            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6356            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6357            'client_key: ' + repr(self.client_key) + ' ' +\
 6358            'database: ' + repr(self.database) + ' ' +\
 6359            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6360            'healthy: ' + repr(self.healthy) + ' ' +\
 6361            'hostname: ' + repr(self.hostname) + ' ' +\
 6362            'id: ' + repr(self.id) + ' ' +\
 6363            'name: ' + repr(self.name) + ' ' +\
 6364            'password: ' + repr(self.password) + ' ' +\
 6365            'port: ' + repr(self.port) + ' ' +\
 6366            'port_override: ' + repr(self.port_override) + ' ' +\
 6367            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6368            'server_name: ' + repr(self.server_name) + ' ' +\
 6369            'tags: ' + repr(self.tags) + ' ' +\
 6370            'username: ' + repr(self.username) + ' ' +\
 6371            '>'
 6372
 6373    def to_dict(self):
 6374        return {
 6375            'bind_interface': self.bind_interface,
 6376            'certificate_authority': self.certificate_authority,
 6377            'client_certificate': self.client_certificate,
 6378            'client_key': self.client_key,
 6379            'database': self.database,
 6380            'egress_filter': self.egress_filter,
 6381            'healthy': self.healthy,
 6382            'hostname': self.hostname,
 6383            'id': self.id,
 6384            'name': self.name,
 6385            'password': self.password,
 6386            'port': self.port,
 6387            'port_override': self.port_override,
 6388            'secret_store_id': self.secret_store_id,
 6389            'server_name': self.server_name,
 6390            'tags': self.tags,
 6391            'username': self.username,
 6392        }
 6393
 6394    @classmethod
 6395    def from_dict(cls, d):
 6396        return cls(
 6397            bind_interface=d.get('bind_interface'),
 6398            certificate_authority=d.get('certificate_authority'),
 6399            client_certificate=d.get('client_certificate'),
 6400            client_key=d.get('client_key'),
 6401            database=d.get('database'),
 6402            egress_filter=d.get('egress_filter'),
 6403            healthy=d.get('healthy'),
 6404            hostname=d.get('hostname'),
 6405            id=d.get('id'),
 6406            name=d.get('name'),
 6407            password=d.get('password'),
 6408            port=d.get('port'),
 6409            port_override=d.get('port_override'),
 6410            secret_store_id=d.get('secret_store_id'),
 6411            server_name=d.get('server_name'),
 6412            tags=d.get('tags'),
 6413            username=d.get('username'),
 6414        )
 6415
 6416
 6417class MTLSPostgres:
 6418    __slots__ = [
 6419        'bind_interface',
 6420        'certificate_authority',
 6421        'client_certificate',
 6422        'client_key',
 6423        'database',
 6424        'egress_filter',
 6425        'healthy',
 6426        'hostname',
 6427        'id',
 6428        'name',
 6429        'override_database',
 6430        'password',
 6431        'port',
 6432        'port_override',
 6433        'secret_store_id',
 6434        'server_name',
 6435        'tags',
 6436        'username',
 6437    ]
 6438
 6439    def __init__(
 6440        self,
 6441        bind_interface=None,
 6442        certificate_authority=None,
 6443        client_certificate=None,
 6444        client_key=None,
 6445        database=None,
 6446        egress_filter=None,
 6447        healthy=None,
 6448        hostname=None,
 6449        id=None,
 6450        name=None,
 6451        override_database=None,
 6452        password=None,
 6453        port=None,
 6454        port_override=None,
 6455        secret_store_id=None,
 6456        server_name=None,
 6457        tags=None,
 6458        username=None,
 6459    ):
 6460        self.bind_interface = bind_interface if bind_interface is not None else ''
 6461        '''
 6462         Bind interface
 6463        '''
 6464        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6465        self.client_certificate = client_certificate if client_certificate is not None else ''
 6466        self.client_key = client_key if client_key is not None else ''
 6467        self.database = database if database is not None else ''
 6468        self.egress_filter = egress_filter if egress_filter is not None else ''
 6469        '''
 6470         A filter applied to the routing logic to pin datasource to nodes.
 6471        '''
 6472        self.healthy = healthy if healthy is not None else False
 6473        '''
 6474         True if the datasource is reachable and the credentials are valid.
 6475        '''
 6476        self.hostname = hostname if hostname is not None else ''
 6477        self.id = id if id is not None else ''
 6478        '''
 6479         Unique identifier of the Resource.
 6480        '''
 6481        self.name = name if name is not None else ''
 6482        '''
 6483         Unique human-readable name of the Resource.
 6484        '''
 6485        self.override_database = override_database if override_database is not None else False
 6486        self.password = password if password is not None else ''
 6487        self.port = port if port is not None else 0
 6488        self.port_override = port_override if port_override is not None else 0
 6489        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6490        '''
 6491         ID of the secret store containing credentials for this resource, if any.
 6492        '''
 6493        self.server_name = server_name if server_name is not None else ''
 6494        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6495        '''
 6496         Tags is a map of key, value pairs.
 6497        '''
 6498        self.username = username if username is not None else ''
 6499
 6500    def __repr__(self):
 6501        return '<sdm.MTLSPostgres ' + \
 6502            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6503            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6504            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6505            'client_key: ' + repr(self.client_key) + ' ' +\
 6506            'database: ' + repr(self.database) + ' ' +\
 6507            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6508            'healthy: ' + repr(self.healthy) + ' ' +\
 6509            'hostname: ' + repr(self.hostname) + ' ' +\
 6510            'id: ' + repr(self.id) + ' ' +\
 6511            'name: ' + repr(self.name) + ' ' +\
 6512            'override_database: ' + repr(self.override_database) + ' ' +\
 6513            'password: ' + repr(self.password) + ' ' +\
 6514            'port: ' + repr(self.port) + ' ' +\
 6515            'port_override: ' + repr(self.port_override) + ' ' +\
 6516            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6517            'server_name: ' + repr(self.server_name) + ' ' +\
 6518            'tags: ' + repr(self.tags) + ' ' +\
 6519            'username: ' + repr(self.username) + ' ' +\
 6520            '>'
 6521
 6522    def to_dict(self):
 6523        return {
 6524            'bind_interface': self.bind_interface,
 6525            'certificate_authority': self.certificate_authority,
 6526            'client_certificate': self.client_certificate,
 6527            'client_key': self.client_key,
 6528            'database': self.database,
 6529            'egress_filter': self.egress_filter,
 6530            'healthy': self.healthy,
 6531            'hostname': self.hostname,
 6532            'id': self.id,
 6533            'name': self.name,
 6534            'override_database': self.override_database,
 6535            'password': self.password,
 6536            'port': self.port,
 6537            'port_override': self.port_override,
 6538            'secret_store_id': self.secret_store_id,
 6539            'server_name': self.server_name,
 6540            'tags': self.tags,
 6541            'username': self.username,
 6542        }
 6543
 6544    @classmethod
 6545    def from_dict(cls, d):
 6546        return cls(
 6547            bind_interface=d.get('bind_interface'),
 6548            certificate_authority=d.get('certificate_authority'),
 6549            client_certificate=d.get('client_certificate'),
 6550            client_key=d.get('client_key'),
 6551            database=d.get('database'),
 6552            egress_filter=d.get('egress_filter'),
 6553            healthy=d.get('healthy'),
 6554            hostname=d.get('hostname'),
 6555            id=d.get('id'),
 6556            name=d.get('name'),
 6557            override_database=d.get('override_database'),
 6558            password=d.get('password'),
 6559            port=d.get('port'),
 6560            port_override=d.get('port_override'),
 6561            secret_store_id=d.get('secret_store_id'),
 6562            server_name=d.get('server_name'),
 6563            tags=d.get('tags'),
 6564            username=d.get('username'),
 6565        )
 6566
 6567
 6568class Maria:
 6569    __slots__ = [
 6570        'bind_interface',
 6571        'database',
 6572        'egress_filter',
 6573        'healthy',
 6574        'hostname',
 6575        'id',
 6576        'name',
 6577        'password',
 6578        'port',
 6579        'port_override',
 6580        'secret_store_id',
 6581        'tags',
 6582        'username',
 6583    ]
 6584
 6585    def __init__(
 6586        self,
 6587        bind_interface=None,
 6588        database=None,
 6589        egress_filter=None,
 6590        healthy=None,
 6591        hostname=None,
 6592        id=None,
 6593        name=None,
 6594        password=None,
 6595        port=None,
 6596        port_override=None,
 6597        secret_store_id=None,
 6598        tags=None,
 6599        username=None,
 6600    ):
 6601        self.bind_interface = bind_interface if bind_interface is not None else ''
 6602        '''
 6603         Bind interface
 6604        '''
 6605        self.database = database if database is not None else ''
 6606        self.egress_filter = egress_filter if egress_filter is not None else ''
 6607        '''
 6608         A filter applied to the routing logic to pin datasource to nodes.
 6609        '''
 6610        self.healthy = healthy if healthy is not None else False
 6611        '''
 6612         True if the datasource is reachable and the credentials are valid.
 6613        '''
 6614        self.hostname = hostname if hostname is not None else ''
 6615        self.id = id if id is not None else ''
 6616        '''
 6617         Unique identifier of the Resource.
 6618        '''
 6619        self.name = name if name is not None else ''
 6620        '''
 6621         Unique human-readable name of the Resource.
 6622        '''
 6623        self.password = password if password is not None else ''
 6624        self.port = port if port is not None else 0
 6625        self.port_override = port_override if port_override is not None else 0
 6626        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6627        '''
 6628         ID of the secret store containing credentials for this resource, if any.
 6629        '''
 6630        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6631        '''
 6632         Tags is a map of key, value pairs.
 6633        '''
 6634        self.username = username if username is not None else ''
 6635
 6636    def __repr__(self):
 6637        return '<sdm.Maria ' + \
 6638            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6639            'database: ' + repr(self.database) + ' ' +\
 6640            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6641            'healthy: ' + repr(self.healthy) + ' ' +\
 6642            'hostname: ' + repr(self.hostname) + ' ' +\
 6643            'id: ' + repr(self.id) + ' ' +\
 6644            'name: ' + repr(self.name) + ' ' +\
 6645            'password: ' + repr(self.password) + ' ' +\
 6646            'port: ' + repr(self.port) + ' ' +\
 6647            'port_override: ' + repr(self.port_override) + ' ' +\
 6648            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6649            'tags: ' + repr(self.tags) + ' ' +\
 6650            'username: ' + repr(self.username) + ' ' +\
 6651            '>'
 6652
 6653    def to_dict(self):
 6654        return {
 6655            'bind_interface': self.bind_interface,
 6656            'database': self.database,
 6657            'egress_filter': self.egress_filter,
 6658            'healthy': self.healthy,
 6659            'hostname': self.hostname,
 6660            'id': self.id,
 6661            'name': self.name,
 6662            'password': self.password,
 6663            'port': self.port,
 6664            'port_override': self.port_override,
 6665            'secret_store_id': self.secret_store_id,
 6666            'tags': self.tags,
 6667            'username': self.username,
 6668        }
 6669
 6670    @classmethod
 6671    def from_dict(cls, d):
 6672        return cls(
 6673            bind_interface=d.get('bind_interface'),
 6674            database=d.get('database'),
 6675            egress_filter=d.get('egress_filter'),
 6676            healthy=d.get('healthy'),
 6677            hostname=d.get('hostname'),
 6678            id=d.get('id'),
 6679            name=d.get('name'),
 6680            password=d.get('password'),
 6681            port=d.get('port'),
 6682            port_override=d.get('port_override'),
 6683            secret_store_id=d.get('secret_store_id'),
 6684            tags=d.get('tags'),
 6685            username=d.get('username'),
 6686        )
 6687
 6688
 6689class Memcached:
 6690    __slots__ = [
 6691        'bind_interface',
 6692        'egress_filter',
 6693        'healthy',
 6694        'hostname',
 6695        'id',
 6696        'name',
 6697        'port',
 6698        'port_override',
 6699        'secret_store_id',
 6700        'tags',
 6701    ]
 6702
 6703    def __init__(
 6704        self,
 6705        bind_interface=None,
 6706        egress_filter=None,
 6707        healthy=None,
 6708        hostname=None,
 6709        id=None,
 6710        name=None,
 6711        port=None,
 6712        port_override=None,
 6713        secret_store_id=None,
 6714        tags=None,
 6715    ):
 6716        self.bind_interface = bind_interface if bind_interface is not None else ''
 6717        '''
 6718         Bind interface
 6719        '''
 6720        self.egress_filter = egress_filter if egress_filter is not None else ''
 6721        '''
 6722         A filter applied to the routing logic to pin datasource to nodes.
 6723        '''
 6724        self.healthy = healthy if healthy is not None else False
 6725        '''
 6726         True if the datasource is reachable and the credentials are valid.
 6727        '''
 6728        self.hostname = hostname if hostname is not None else ''
 6729        self.id = id if id is not None else ''
 6730        '''
 6731         Unique identifier of the Resource.
 6732        '''
 6733        self.name = name if name is not None else ''
 6734        '''
 6735         Unique human-readable name of the Resource.
 6736        '''
 6737        self.port = port if port is not None else 0
 6738        self.port_override = port_override if port_override is not None else 0
 6739        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6740        '''
 6741         ID of the secret store containing credentials for this resource, if any.
 6742        '''
 6743        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6744        '''
 6745         Tags is a map of key, value pairs.
 6746        '''
 6747
 6748    def __repr__(self):
 6749        return '<sdm.Memcached ' + \
 6750            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6751            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6752            'healthy: ' + repr(self.healthy) + ' ' +\
 6753            'hostname: ' + repr(self.hostname) + ' ' +\
 6754            'id: ' + repr(self.id) + ' ' +\
 6755            'name: ' + repr(self.name) + ' ' +\
 6756            'port: ' + repr(self.port) + ' ' +\
 6757            'port_override: ' + repr(self.port_override) + ' ' +\
 6758            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6759            'tags: ' + repr(self.tags) + ' ' +\
 6760            '>'
 6761
 6762    def to_dict(self):
 6763        return {
 6764            'bind_interface': self.bind_interface,
 6765            'egress_filter': self.egress_filter,
 6766            'healthy': self.healthy,
 6767            'hostname': self.hostname,
 6768            'id': self.id,
 6769            'name': self.name,
 6770            'port': self.port,
 6771            'port_override': self.port_override,
 6772            'secret_store_id': self.secret_store_id,
 6773            'tags': self.tags,
 6774        }
 6775
 6776    @classmethod
 6777    def from_dict(cls, d):
 6778        return cls(
 6779            bind_interface=d.get('bind_interface'),
 6780            egress_filter=d.get('egress_filter'),
 6781            healthy=d.get('healthy'),
 6782            hostname=d.get('hostname'),
 6783            id=d.get('id'),
 6784            name=d.get('name'),
 6785            port=d.get('port'),
 6786            port_override=d.get('port_override'),
 6787            secret_store_id=d.get('secret_store_id'),
 6788            tags=d.get('tags'),
 6789        )
 6790
 6791
 6792class Memsql:
 6793    __slots__ = [
 6794        'bind_interface',
 6795        'database',
 6796        'egress_filter',
 6797        'healthy',
 6798        'hostname',
 6799        'id',
 6800        'name',
 6801        'password',
 6802        'port',
 6803        'port_override',
 6804        'secret_store_id',
 6805        'tags',
 6806        'username',
 6807    ]
 6808
 6809    def __init__(
 6810        self,
 6811        bind_interface=None,
 6812        database=None,
 6813        egress_filter=None,
 6814        healthy=None,
 6815        hostname=None,
 6816        id=None,
 6817        name=None,
 6818        password=None,
 6819        port=None,
 6820        port_override=None,
 6821        secret_store_id=None,
 6822        tags=None,
 6823        username=None,
 6824    ):
 6825        self.bind_interface = bind_interface if bind_interface is not None else ''
 6826        '''
 6827         Bind interface
 6828        '''
 6829        self.database = database if database is not None else ''
 6830        self.egress_filter = egress_filter if egress_filter is not None else ''
 6831        '''
 6832         A filter applied to the routing logic to pin datasource to nodes.
 6833        '''
 6834        self.healthy = healthy if healthy is not None else False
 6835        '''
 6836         True if the datasource is reachable and the credentials are valid.
 6837        '''
 6838        self.hostname = hostname if hostname is not None else ''
 6839        self.id = id if id is not None else ''
 6840        '''
 6841         Unique identifier of the Resource.
 6842        '''
 6843        self.name = name if name is not None else ''
 6844        '''
 6845         Unique human-readable name of the Resource.
 6846        '''
 6847        self.password = password if password is not None else ''
 6848        self.port = port if port is not None else 0
 6849        self.port_override = port_override if port_override is not None else 0
 6850        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6851        '''
 6852         ID of the secret store containing credentials for this resource, if any.
 6853        '''
 6854        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6855        '''
 6856         Tags is a map of key, value pairs.
 6857        '''
 6858        self.username = username if username is not None else ''
 6859
 6860    def __repr__(self):
 6861        return '<sdm.Memsql ' + \
 6862            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6863            'database: ' + repr(self.database) + ' ' +\
 6864            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6865            'healthy: ' + repr(self.healthy) + ' ' +\
 6866            'hostname: ' + repr(self.hostname) + ' ' +\
 6867            'id: ' + repr(self.id) + ' ' +\
 6868            'name: ' + repr(self.name) + ' ' +\
 6869            'password: ' + repr(self.password) + ' ' +\
 6870            'port: ' + repr(self.port) + ' ' +\
 6871            'port_override: ' + repr(self.port_override) + ' ' +\
 6872            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6873            'tags: ' + repr(self.tags) + ' ' +\
 6874            'username: ' + repr(self.username) + ' ' +\
 6875            '>'
 6876
 6877    def to_dict(self):
 6878        return {
 6879            'bind_interface': self.bind_interface,
 6880            'database': self.database,
 6881            'egress_filter': self.egress_filter,
 6882            'healthy': self.healthy,
 6883            'hostname': self.hostname,
 6884            'id': self.id,
 6885            'name': self.name,
 6886            'password': self.password,
 6887            'port': self.port,
 6888            'port_override': self.port_override,
 6889            'secret_store_id': self.secret_store_id,
 6890            'tags': self.tags,
 6891            'username': self.username,
 6892        }
 6893
 6894    @classmethod
 6895    def from_dict(cls, d):
 6896        return cls(
 6897            bind_interface=d.get('bind_interface'),
 6898            database=d.get('database'),
 6899            egress_filter=d.get('egress_filter'),
 6900            healthy=d.get('healthy'),
 6901            hostname=d.get('hostname'),
 6902            id=d.get('id'),
 6903            name=d.get('name'),
 6904            password=d.get('password'),
 6905            port=d.get('port'),
 6906            port_override=d.get('port_override'),
 6907            secret_store_id=d.get('secret_store_id'),
 6908            tags=d.get('tags'),
 6909            username=d.get('username'),
 6910        )
 6911
 6912
 6913class MongoHost:
 6914    '''
 6915    MongoHost is currently unstable, and its API may change, or it may be removed,
 6916    without a major version bump.
 6917    '''
 6918    __slots__ = [
 6919        'auth_database',
 6920        'bind_interface',
 6921        'egress_filter',
 6922        'healthy',
 6923        'hostname',
 6924        'id',
 6925        'name',
 6926        'password',
 6927        'port',
 6928        'port_override',
 6929        'secret_store_id',
 6930        'tags',
 6931        'tls_required',
 6932        'username',
 6933    ]
 6934
 6935    def __init__(
 6936        self,
 6937        auth_database=None,
 6938        bind_interface=None,
 6939        egress_filter=None,
 6940        healthy=None,
 6941        hostname=None,
 6942        id=None,
 6943        name=None,
 6944        password=None,
 6945        port=None,
 6946        port_override=None,
 6947        secret_store_id=None,
 6948        tags=None,
 6949        tls_required=None,
 6950        username=None,
 6951    ):
 6952        self.auth_database = auth_database if auth_database is not None else ''
 6953        self.bind_interface = bind_interface if bind_interface is not None else ''
 6954        '''
 6955         Bind interface
 6956        '''
 6957        self.egress_filter = egress_filter if egress_filter is not None else ''
 6958        '''
 6959         A filter applied to the routing logic to pin datasource to nodes.
 6960        '''
 6961        self.healthy = healthy if healthy is not None else False
 6962        '''
 6963         True if the datasource is reachable and the credentials are valid.
 6964        '''
 6965        self.hostname = hostname if hostname is not None else ''
 6966        self.id = id if id is not None else ''
 6967        '''
 6968         Unique identifier of the Resource.
 6969        '''
 6970        self.name = name if name is not None else ''
 6971        '''
 6972         Unique human-readable name of the Resource.
 6973        '''
 6974        self.password = password if password is not None else ''
 6975        self.port = port if port is not None else 0
 6976        self.port_override = port_override if port_override is not None else 0
 6977        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6978        '''
 6979         ID of the secret store containing credentials for this resource, if any.
 6980        '''
 6981        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6982        '''
 6983         Tags is a map of key, value pairs.
 6984        '''
 6985        self.tls_required = tls_required if tls_required is not None else False
 6986        self.username = username if username is not None else ''
 6987
 6988    def __repr__(self):
 6989        return '<sdm.MongoHost ' + \
 6990            'auth_database: ' + repr(self.auth_database) + ' ' +\
 6991            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6992            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6993            'healthy: ' + repr(self.healthy) + ' ' +\
 6994            'hostname: ' + repr(self.hostname) + ' ' +\
 6995            'id: ' + repr(self.id) + ' ' +\
 6996            'name: ' + repr(self.name) + ' ' +\
 6997            'password: ' + repr(self.password) + ' ' +\
 6998            'port: ' + repr(self.port) + ' ' +\
 6999            'port_override: ' + repr(self.port_override) + ' ' +\
 7000            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7001            'tags: ' + repr(self.tags) + ' ' +\
 7002            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7003            'username: ' + repr(self.username) + ' ' +\
 7004            '>'
 7005
 7006    def to_dict(self):
 7007        return {
 7008            'auth_database': self.auth_database,
 7009            'bind_interface': self.bind_interface,
 7010            'egress_filter': self.egress_filter,
 7011            'healthy': self.healthy,
 7012            'hostname': self.hostname,
 7013            'id': self.id,
 7014            'name': self.name,
 7015            'password': self.password,
 7016            'port': self.port,
 7017            'port_override': self.port_override,
 7018            'secret_store_id': self.secret_store_id,
 7019            'tags': self.tags,
 7020            'tls_required': self.tls_required,
 7021            'username': self.username,
 7022        }
 7023
 7024    @classmethod
 7025    def from_dict(cls, d):
 7026        return cls(
 7027            auth_database=d.get('auth_database'),
 7028            bind_interface=d.get('bind_interface'),
 7029            egress_filter=d.get('egress_filter'),
 7030            healthy=d.get('healthy'),
 7031            hostname=d.get('hostname'),
 7032            id=d.get('id'),
 7033            name=d.get('name'),
 7034            password=d.get('password'),
 7035            port=d.get('port'),
 7036            port_override=d.get('port_override'),
 7037            secret_store_id=d.get('secret_store_id'),
 7038            tags=d.get('tags'),
 7039            tls_required=d.get('tls_required'),
 7040            username=d.get('username'),
 7041        )
 7042
 7043
 7044class MongoLegacyHost:
 7045    __slots__ = [
 7046        'auth_database',
 7047        'bind_interface',
 7048        'egress_filter',
 7049        'healthy',
 7050        'hostname',
 7051        'id',
 7052        'name',
 7053        'password',
 7054        'port',
 7055        'port_override',
 7056        'replica_set',
 7057        'secret_store_id',
 7058        'tags',
 7059        'tls_required',
 7060        'username',
 7061    ]
 7062
 7063    def __init__(
 7064        self,
 7065        auth_database=None,
 7066        bind_interface=None,
 7067        egress_filter=None,
 7068        healthy=None,
 7069        hostname=None,
 7070        id=None,
 7071        name=None,
 7072        password=None,
 7073        port=None,
 7074        port_override=None,
 7075        replica_set=None,
 7076        secret_store_id=None,
 7077        tags=None,
 7078        tls_required=None,
 7079        username=None,
 7080    ):
 7081        self.auth_database = auth_database if auth_database is not None else ''
 7082        self.bind_interface = bind_interface if bind_interface is not None else ''
 7083        '''
 7084         Bind interface
 7085        '''
 7086        self.egress_filter = egress_filter if egress_filter is not None else ''
 7087        '''
 7088         A filter applied to the routing logic to pin datasource to nodes.
 7089        '''
 7090        self.healthy = healthy if healthy is not None else False
 7091        '''
 7092         True if the datasource is reachable and the credentials are valid.
 7093        '''
 7094        self.hostname = hostname if hostname is not None else ''
 7095        self.id = id if id is not None else ''
 7096        '''
 7097         Unique identifier of the Resource.
 7098        '''
 7099        self.name = name if name is not None else ''
 7100        '''
 7101         Unique human-readable name of the Resource.
 7102        '''
 7103        self.password = password if password is not None else ''
 7104        self.port = port if port is not None else 0
 7105        self.port_override = port_override if port_override is not None else 0
 7106        self.replica_set = replica_set if replica_set is not None else ''
 7107        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7108        '''
 7109         ID of the secret store containing credentials for this resource, if any.
 7110        '''
 7111        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7112        '''
 7113         Tags is a map of key, value pairs.
 7114        '''
 7115        self.tls_required = tls_required if tls_required is not None else False
 7116        self.username = username if username is not None else ''
 7117
 7118    def __repr__(self):
 7119        return '<sdm.MongoLegacyHost ' + \
 7120            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7121            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7122            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7123            'healthy: ' + repr(self.healthy) + ' ' +\
 7124            'hostname: ' + repr(self.hostname) + ' ' +\
 7125            'id: ' + repr(self.id) + ' ' +\
 7126            'name: ' + repr(self.name) + ' ' +\
 7127            'password: ' + repr(self.password) + ' ' +\
 7128            'port: ' + repr(self.port) + ' ' +\
 7129            'port_override: ' + repr(self.port_override) + ' ' +\
 7130            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7131            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7132            'tags: ' + repr(self.tags) + ' ' +\
 7133            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7134            'username: ' + repr(self.username) + ' ' +\
 7135            '>'
 7136
 7137    def to_dict(self):
 7138        return {
 7139            'auth_database': self.auth_database,
 7140            'bind_interface': self.bind_interface,
 7141            'egress_filter': self.egress_filter,
 7142            'healthy': self.healthy,
 7143            'hostname': self.hostname,
 7144            'id': self.id,
 7145            'name': self.name,
 7146            'password': self.password,
 7147            'port': self.port,
 7148            'port_override': self.port_override,
 7149            'replica_set': self.replica_set,
 7150            'secret_store_id': self.secret_store_id,
 7151            'tags': self.tags,
 7152            'tls_required': self.tls_required,
 7153            'username': self.username,
 7154        }
 7155
 7156    @classmethod
 7157    def from_dict(cls, d):
 7158        return cls(
 7159            auth_database=d.get('auth_database'),
 7160            bind_interface=d.get('bind_interface'),
 7161            egress_filter=d.get('egress_filter'),
 7162            healthy=d.get('healthy'),
 7163            hostname=d.get('hostname'),
 7164            id=d.get('id'),
 7165            name=d.get('name'),
 7166            password=d.get('password'),
 7167            port=d.get('port'),
 7168            port_override=d.get('port_override'),
 7169            replica_set=d.get('replica_set'),
 7170            secret_store_id=d.get('secret_store_id'),
 7171            tags=d.get('tags'),
 7172            tls_required=d.get('tls_required'),
 7173            username=d.get('username'),
 7174        )
 7175
 7176
 7177class MongoLegacyReplicaset:
 7178    __slots__ = [
 7179        'auth_database',
 7180        'bind_interface',
 7181        'connect_to_replica',
 7182        'egress_filter',
 7183        'healthy',
 7184        'hostname',
 7185        'id',
 7186        'name',
 7187        'password',
 7188        'port',
 7189        'port_override',
 7190        'replica_set',
 7191        'secret_store_id',
 7192        'tags',
 7193        'tls_required',
 7194        'username',
 7195    ]
 7196
 7197    def __init__(
 7198        self,
 7199        auth_database=None,
 7200        bind_interface=None,
 7201        connect_to_replica=None,
 7202        egress_filter=None,
 7203        healthy=None,
 7204        hostname=None,
 7205        id=None,
 7206        name=None,
 7207        password=None,
 7208        port=None,
 7209        port_override=None,
 7210        replica_set=None,
 7211        secret_store_id=None,
 7212        tags=None,
 7213        tls_required=None,
 7214        username=None,
 7215    ):
 7216        self.auth_database = auth_database if auth_database is not None else ''
 7217        self.bind_interface = bind_interface if bind_interface is not None else ''
 7218        '''
 7219         Bind interface
 7220        '''
 7221        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7222        self.egress_filter = egress_filter if egress_filter is not None else ''
 7223        '''
 7224         A filter applied to the routing logic to pin datasource to nodes.
 7225        '''
 7226        self.healthy = healthy if healthy is not None else False
 7227        '''
 7228         True if the datasource is reachable and the credentials are valid.
 7229        '''
 7230        self.hostname = hostname if hostname is not None else ''
 7231        self.id = id if id is not None else ''
 7232        '''
 7233         Unique identifier of the Resource.
 7234        '''
 7235        self.name = name if name is not None else ''
 7236        '''
 7237         Unique human-readable name of the Resource.
 7238        '''
 7239        self.password = password if password is not None else ''
 7240        self.port = port if port is not None else 0
 7241        self.port_override = port_override if port_override is not None else 0
 7242        self.replica_set = replica_set if replica_set is not None else ''
 7243        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7244        '''
 7245         ID of the secret store containing credentials for this resource, if any.
 7246        '''
 7247        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7248        '''
 7249         Tags is a map of key, value pairs.
 7250        '''
 7251        self.tls_required = tls_required if tls_required is not None else False
 7252        self.username = username if username is not None else ''
 7253
 7254    def __repr__(self):
 7255        return '<sdm.MongoLegacyReplicaset ' + \
 7256            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7257            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7258            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7259            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7260            'healthy: ' + repr(self.healthy) + ' ' +\
 7261            'hostname: ' + repr(self.hostname) + ' ' +\
 7262            'id: ' + repr(self.id) + ' ' +\
 7263            'name: ' + repr(self.name) + ' ' +\
 7264            'password: ' + repr(self.password) + ' ' +\
 7265            'port: ' + repr(self.port) + ' ' +\
 7266            'port_override: ' + repr(self.port_override) + ' ' +\
 7267            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7268            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7269            'tags: ' + repr(self.tags) + ' ' +\
 7270            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7271            'username: ' + repr(self.username) + ' ' +\
 7272            '>'
 7273
 7274    def to_dict(self):
 7275        return {
 7276            'auth_database': self.auth_database,
 7277            'bind_interface': self.bind_interface,
 7278            'connect_to_replica': self.connect_to_replica,
 7279            'egress_filter': self.egress_filter,
 7280            'healthy': self.healthy,
 7281            'hostname': self.hostname,
 7282            'id': self.id,
 7283            'name': self.name,
 7284            'password': self.password,
 7285            'port': self.port,
 7286            'port_override': self.port_override,
 7287            'replica_set': self.replica_set,
 7288            'secret_store_id': self.secret_store_id,
 7289            'tags': self.tags,
 7290            'tls_required': self.tls_required,
 7291            'username': self.username,
 7292        }
 7293
 7294    @classmethod
 7295    def from_dict(cls, d):
 7296        return cls(
 7297            auth_database=d.get('auth_database'),
 7298            bind_interface=d.get('bind_interface'),
 7299            connect_to_replica=d.get('connect_to_replica'),
 7300            egress_filter=d.get('egress_filter'),
 7301            healthy=d.get('healthy'),
 7302            hostname=d.get('hostname'),
 7303            id=d.get('id'),
 7304            name=d.get('name'),
 7305            password=d.get('password'),
 7306            port=d.get('port'),
 7307            port_override=d.get('port_override'),
 7308            replica_set=d.get('replica_set'),
 7309            secret_store_id=d.get('secret_store_id'),
 7310            tags=d.get('tags'),
 7311            tls_required=d.get('tls_required'),
 7312            username=d.get('username'),
 7313        )
 7314
 7315
 7316class MongoReplicaSet:
 7317    '''
 7318    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
 7319    without a major version bump.
 7320    '''
 7321    __slots__ = [
 7322        'auth_database',
 7323        'bind_interface',
 7324        'connect_to_replica',
 7325        'egress_filter',
 7326        'healthy',
 7327        'hostname',
 7328        'id',
 7329        'name',
 7330        'password',
 7331        'port',
 7332        'port_override',
 7333        'replica_set',
 7334        'secret_store_id',
 7335        'tags',
 7336        'tls_required',
 7337        'username',
 7338    ]
 7339
 7340    def __init__(
 7341        self,
 7342        auth_database=None,
 7343        bind_interface=None,
 7344        connect_to_replica=None,
 7345        egress_filter=None,
 7346        healthy=None,
 7347        hostname=None,
 7348        id=None,
 7349        name=None,
 7350        password=None,
 7351        port=None,
 7352        port_override=None,
 7353        replica_set=None,
 7354        secret_store_id=None,
 7355        tags=None,
 7356        tls_required=None,
 7357        username=None,
 7358    ):
 7359        self.auth_database = auth_database if auth_database is not None else ''
 7360        self.bind_interface = bind_interface if bind_interface is not None else ''
 7361        '''
 7362         Bind interface
 7363        '''
 7364        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7365        self.egress_filter = egress_filter if egress_filter is not None else ''
 7366        '''
 7367         A filter applied to the routing logic to pin datasource to nodes.
 7368        '''
 7369        self.healthy = healthy if healthy is not None else False
 7370        '''
 7371         True if the datasource is reachable and the credentials are valid.
 7372        '''
 7373        self.hostname = hostname if hostname is not None else ''
 7374        self.id = id if id is not None else ''
 7375        '''
 7376         Unique identifier of the Resource.
 7377        '''
 7378        self.name = name if name is not None else ''
 7379        '''
 7380         Unique human-readable name of the Resource.
 7381        '''
 7382        self.password = password if password is not None else ''
 7383        self.port = port if port is not None else 0
 7384        self.port_override = port_override if port_override is not None else 0
 7385        self.replica_set = replica_set if replica_set is not None else ''
 7386        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7387        '''
 7388         ID of the secret store containing credentials for this resource, if any.
 7389        '''
 7390        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7391        '''
 7392         Tags is a map of key, value pairs.
 7393        '''
 7394        self.tls_required = tls_required if tls_required is not None else False
 7395        self.username = username if username is not None else ''
 7396
 7397    def __repr__(self):
 7398        return '<sdm.MongoReplicaSet ' + \
 7399            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7400            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7401            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7402            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7403            'healthy: ' + repr(self.healthy) + ' ' +\
 7404            'hostname: ' + repr(self.hostname) + ' ' +\
 7405            'id: ' + repr(self.id) + ' ' +\
 7406            'name: ' + repr(self.name) + ' ' +\
 7407            'password: ' + repr(self.password) + ' ' +\
 7408            'port: ' + repr(self.port) + ' ' +\
 7409            'port_override: ' + repr(self.port_override) + ' ' +\
 7410            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7411            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7412            'tags: ' + repr(self.tags) + ' ' +\
 7413            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7414            'username: ' + repr(self.username) + ' ' +\
 7415            '>'
 7416
 7417    def to_dict(self):
 7418        return {
 7419            'auth_database': self.auth_database,
 7420            'bind_interface': self.bind_interface,
 7421            'connect_to_replica': self.connect_to_replica,
 7422            'egress_filter': self.egress_filter,
 7423            'healthy': self.healthy,
 7424            'hostname': self.hostname,
 7425            'id': self.id,
 7426            'name': self.name,
 7427            'password': self.password,
 7428            'port': self.port,
 7429            'port_override': self.port_override,
 7430            'replica_set': self.replica_set,
 7431            'secret_store_id': self.secret_store_id,
 7432            'tags': self.tags,
 7433            'tls_required': self.tls_required,
 7434            'username': self.username,
 7435        }
 7436
 7437    @classmethod
 7438    def from_dict(cls, d):
 7439        return cls(
 7440            auth_database=d.get('auth_database'),
 7441            bind_interface=d.get('bind_interface'),
 7442            connect_to_replica=d.get('connect_to_replica'),
 7443            egress_filter=d.get('egress_filter'),
 7444            healthy=d.get('healthy'),
 7445            hostname=d.get('hostname'),
 7446            id=d.get('id'),
 7447            name=d.get('name'),
 7448            password=d.get('password'),
 7449            port=d.get('port'),
 7450            port_override=d.get('port_override'),
 7451            replica_set=d.get('replica_set'),
 7452            secret_store_id=d.get('secret_store_id'),
 7453            tags=d.get('tags'),
 7454            tls_required=d.get('tls_required'),
 7455            username=d.get('username'),
 7456        )
 7457
 7458
 7459class MongoShardedCluster:
 7460    '''
 7461    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
 7462    without a major version bump.
 7463    '''
 7464    __slots__ = [
 7465        'auth_database',
 7466        'bind_interface',
 7467        'egress_filter',
 7468        'healthy',
 7469        'hostname',
 7470        'id',
 7471        'name',
 7472        'password',
 7473        'port_override',
 7474        'secret_store_id',
 7475        'tags',
 7476        'tls_required',
 7477        'username',
 7478    ]
 7479
 7480    def __init__(
 7481        self,
 7482        auth_database=None,
 7483        bind_interface=None,
 7484        egress_filter=None,
 7485        healthy=None,
 7486        hostname=None,
 7487        id=None,
 7488        name=None,
 7489        password=None,
 7490        port_override=None,
 7491        secret_store_id=None,
 7492        tags=None,
 7493        tls_required=None,
 7494        username=None,
 7495    ):
 7496        self.auth_database = auth_database if auth_database is not None else ''
 7497        self.bind_interface = bind_interface if bind_interface is not None else ''
 7498        '''
 7499         Bind interface
 7500        '''
 7501        self.egress_filter = egress_filter if egress_filter is not None else ''
 7502        '''
 7503         A filter applied to the routing logic to pin datasource to nodes.
 7504        '''
 7505        self.healthy = healthy if healthy is not None else False
 7506        '''
 7507         True if the datasource is reachable and the credentials are valid.
 7508        '''
 7509        self.hostname = hostname if hostname is not None else ''
 7510        self.id = id if id is not None else ''
 7511        '''
 7512         Unique identifier of the Resource.
 7513        '''
 7514        self.name = name if name is not None else ''
 7515        '''
 7516         Unique human-readable name of the Resource.
 7517        '''
 7518        self.password = password if password is not None else ''
 7519        self.port_override = port_override if port_override is not None else 0
 7520        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7521        '''
 7522         ID of the secret store containing credentials for this resource, if any.
 7523        '''
 7524        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7525        '''
 7526         Tags is a map of key, value pairs.
 7527        '''
 7528        self.tls_required = tls_required if tls_required is not None else False
 7529        self.username = username if username is not None else ''
 7530
 7531    def __repr__(self):
 7532        return '<sdm.MongoShardedCluster ' + \
 7533            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7534            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7535            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7536            'healthy: ' + repr(self.healthy) + ' ' +\
 7537            'hostname: ' + repr(self.hostname) + ' ' +\
 7538            'id: ' + repr(self.id) + ' ' +\
 7539            'name: ' + repr(self.name) + ' ' +\
 7540            'password: ' + repr(self.password) + ' ' +\
 7541            'port_override: ' + repr(self.port_override) + ' ' +\
 7542            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7543            'tags: ' + repr(self.tags) + ' ' +\
 7544            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7545            'username: ' + repr(self.username) + ' ' +\
 7546            '>'
 7547
 7548    def to_dict(self):
 7549        return {
 7550            'auth_database': self.auth_database,
 7551            'bind_interface': self.bind_interface,
 7552            'egress_filter': self.egress_filter,
 7553            'healthy': self.healthy,
 7554            'hostname': self.hostname,
 7555            'id': self.id,
 7556            'name': self.name,
 7557            'password': self.password,
 7558            'port_override': self.port_override,
 7559            'secret_store_id': self.secret_store_id,
 7560            'tags': self.tags,
 7561            'tls_required': self.tls_required,
 7562            'username': self.username,
 7563        }
 7564
 7565    @classmethod
 7566    def from_dict(cls, d):
 7567        return cls(
 7568            auth_database=d.get('auth_database'),
 7569            bind_interface=d.get('bind_interface'),
 7570            egress_filter=d.get('egress_filter'),
 7571            healthy=d.get('healthy'),
 7572            hostname=d.get('hostname'),
 7573            id=d.get('id'),
 7574            name=d.get('name'),
 7575            password=d.get('password'),
 7576            port_override=d.get('port_override'),
 7577            secret_store_id=d.get('secret_store_id'),
 7578            tags=d.get('tags'),
 7579            tls_required=d.get('tls_required'),
 7580            username=d.get('username'),
 7581        )
 7582
 7583
 7584class Mysql:
 7585    __slots__ = [
 7586        'bind_interface',
 7587        'database',
 7588        'egress_filter',
 7589        'healthy',
 7590        'hostname',
 7591        'id',
 7592        'name',
 7593        'password',
 7594        'port',
 7595        'port_override',
 7596        'secret_store_id',
 7597        'tags',
 7598        'username',
 7599    ]
 7600
 7601    def __init__(
 7602        self,
 7603        bind_interface=None,
 7604        database=None,
 7605        egress_filter=None,
 7606        healthy=None,
 7607        hostname=None,
 7608        id=None,
 7609        name=None,
 7610        password=None,
 7611        port=None,
 7612        port_override=None,
 7613        secret_store_id=None,
 7614        tags=None,
 7615        username=None,
 7616    ):
 7617        self.bind_interface = bind_interface if bind_interface is not None else ''
 7618        '''
 7619         Bind interface
 7620        '''
 7621        self.database = database if database is not None else ''
 7622        self.egress_filter = egress_filter if egress_filter is not None else ''
 7623        '''
 7624         A filter applied to the routing logic to pin datasource to nodes.
 7625        '''
 7626        self.healthy = healthy if healthy is not None else False
 7627        '''
 7628         True if the datasource is reachable and the credentials are valid.
 7629        '''
 7630        self.hostname = hostname if hostname is not None else ''
 7631        self.id = id if id is not None else ''
 7632        '''
 7633         Unique identifier of the Resource.
 7634        '''
 7635        self.name = name if name is not None else ''
 7636        '''
 7637         Unique human-readable name of the Resource.
 7638        '''
 7639        self.password = password if password is not None else ''
 7640        self.port = port if port is not None else 0
 7641        self.port_override = port_override if port_override is not None else 0
 7642        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7643        '''
 7644         ID of the secret store containing credentials for this resource, if any.
 7645        '''
 7646        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7647        '''
 7648         Tags is a map of key, value pairs.
 7649        '''
 7650        self.username = username if username is not None else ''
 7651
 7652    def __repr__(self):
 7653        return '<sdm.Mysql ' + \
 7654            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7655            'database: ' + repr(self.database) + ' ' +\
 7656            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7657            'healthy: ' + repr(self.healthy) + ' ' +\
 7658            'hostname: ' + repr(self.hostname) + ' ' +\
 7659            'id: ' + repr(self.id) + ' ' +\
 7660            'name: ' + repr(self.name) + ' ' +\
 7661            'password: ' + repr(self.password) + ' ' +\
 7662            'port: ' + repr(self.port) + ' ' +\
 7663            'port_override: ' + repr(self.port_override) + ' ' +\
 7664            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7665            'tags: ' + repr(self.tags) + ' ' +\
 7666            'username: ' + repr(self.username) + ' ' +\
 7667            '>'
 7668
 7669    def to_dict(self):
 7670        return {
 7671            'bind_interface': self.bind_interface,
 7672            'database': self.database,
 7673            'egress_filter': self.egress_filter,
 7674            'healthy': self.healthy,
 7675            'hostname': self.hostname,
 7676            'id': self.id,
 7677            'name': self.name,
 7678            'password': self.password,
 7679            'port': self.port,
 7680            'port_override': self.port_override,
 7681            'secret_store_id': self.secret_store_id,
 7682            'tags': self.tags,
 7683            'username': self.username,
 7684        }
 7685
 7686    @classmethod
 7687    def from_dict(cls, d):
 7688        return cls(
 7689            bind_interface=d.get('bind_interface'),
 7690            database=d.get('database'),
 7691            egress_filter=d.get('egress_filter'),
 7692            healthy=d.get('healthy'),
 7693            hostname=d.get('hostname'),
 7694            id=d.get('id'),
 7695            name=d.get('name'),
 7696            password=d.get('password'),
 7697            port=d.get('port'),
 7698            port_override=d.get('port_override'),
 7699            secret_store_id=d.get('secret_store_id'),
 7700            tags=d.get('tags'),
 7701            username=d.get('username'),
 7702        )
 7703
 7704
 7705class Neptune:
 7706    __slots__ = [
 7707        'bind_interface',
 7708        'egress_filter',
 7709        'endpoint',
 7710        'healthy',
 7711        'id',
 7712        'name',
 7713        'port',
 7714        'port_override',
 7715        'secret_store_id',
 7716        'tags',
 7717    ]
 7718
 7719    def __init__(
 7720        self,
 7721        bind_interface=None,
 7722        egress_filter=None,
 7723        endpoint=None,
 7724        healthy=None,
 7725        id=None,
 7726        name=None,
 7727        port=None,
 7728        port_override=None,
 7729        secret_store_id=None,
 7730        tags=None,
 7731    ):
 7732        self.bind_interface = bind_interface if bind_interface is not None else ''
 7733        '''
 7734         Bind interface
 7735        '''
 7736        self.egress_filter = egress_filter if egress_filter is not None else ''
 7737        '''
 7738         A filter applied to the routing logic to pin datasource to nodes.
 7739        '''
 7740        self.endpoint = endpoint if endpoint is not None else ''
 7741        self.healthy = healthy if healthy is not None else False
 7742        '''
 7743         True if the datasource is reachable and the credentials are valid.
 7744        '''
 7745        self.id = id if id is not None else ''
 7746        '''
 7747         Unique identifier of the Resource.
 7748        '''
 7749        self.name = name if name is not None else ''
 7750        '''
 7751         Unique human-readable name of the Resource.
 7752        '''
 7753        self.port = port if port is not None else 0
 7754        self.port_override = port_override if port_override is not None else 0
 7755        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7756        '''
 7757         ID of the secret store containing credentials for this resource, if any.
 7758        '''
 7759        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7760        '''
 7761         Tags is a map of key, value pairs.
 7762        '''
 7763
 7764    def __repr__(self):
 7765        return '<sdm.Neptune ' + \
 7766            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7767            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7768            'endpoint: ' + repr(self.endpoint) + ' ' +\
 7769            'healthy: ' + repr(self.healthy) + ' ' +\
 7770            'id: ' + repr(self.id) + ' ' +\
 7771            'name: ' + repr(self.name) + ' ' +\
 7772            'port: ' + repr(self.port) + ' ' +\
 7773            'port_override: ' + repr(self.port_override) + ' ' +\
 7774            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7775            'tags: ' + repr(self.tags) + ' ' +\
 7776            '>'
 7777
 7778    def to_dict(self):
 7779        return {
 7780            'bind_interface': self.bind_interface,
 7781            'egress_filter': self.egress_filter,
 7782            'endpoint': self.endpoint,
 7783            'healthy': self.healthy,
 7784            'id': self.id,
 7785            'name': self.name,
 7786            'port': self.port,
 7787            'port_override': self.port_override,
 7788            'secret_store_id': self.secret_store_id,
 7789            'tags': self.tags,
 7790        }
 7791
 7792    @classmethod
 7793    def from_dict(cls, d):
 7794        return cls(
 7795            bind_interface=d.get('bind_interface'),
 7796            egress_filter=d.get('egress_filter'),
 7797            endpoint=d.get('endpoint'),
 7798            healthy=d.get('healthy'),
 7799            id=d.get('id'),
 7800            name=d.get('name'),
 7801            port=d.get('port'),
 7802            port_override=d.get('port_override'),
 7803            secret_store_id=d.get('secret_store_id'),
 7804            tags=d.get('tags'),
 7805        )
 7806
 7807
 7808class NeptuneIAM:
 7809    __slots__ = [
 7810        'access_key',
 7811        'bind_interface',
 7812        'egress_filter',
 7813        'endpoint',
 7814        'healthy',
 7815        'id',
 7816        'name',
 7817        'port',
 7818        'port_override',
 7819        'region',
 7820        'role_arn',
 7821        'role_external_id',
 7822        'secret_access_key',
 7823        'secret_store_id',
 7824        'tags',
 7825    ]
 7826
 7827    def __init__(
 7828        self,
 7829        access_key=None,
 7830        bind_interface=None,
 7831        egress_filter=None,
 7832        endpoint=None,
 7833        healthy=None,
 7834        id=None,
 7835        name=None,
 7836        port=None,
 7837        port_override=None,
 7838        region=None,
 7839        role_arn=None,
 7840        role_external_id=None,
 7841        secret_access_key=None,
 7842        secret_store_id=None,
 7843        tags=None,
 7844    ):
 7845        self.access_key = access_key if access_key is not None else ''
 7846        self.bind_interface = bind_interface if bind_interface is not None else ''
 7847        '''
 7848         Bind interface
 7849        '''
 7850        self.egress_filter = egress_filter if egress_filter is not None else ''
 7851        '''
 7852         A filter applied to the routing logic to pin datasource to nodes.
 7853        '''
 7854        self.endpoint = endpoint if endpoint is not None else ''
 7855        self.healthy = healthy if healthy is not None else False
 7856        '''
 7857         True if the datasource is reachable and the credentials are valid.
 7858        '''
 7859        self.id = id if id is not None else ''
 7860        '''
 7861         Unique identifier of the Resource.
 7862        '''
 7863        self.name = name if name is not None else ''
 7864        '''
 7865         Unique human-readable name of the Resource.
 7866        '''
 7867        self.port = port if port is not None else 0
 7868        self.port_override = port_override if port_override is not None else 0
 7869        self.region = region if region is not None else ''
 7870        self.role_arn = role_arn if role_arn is not None else ''
 7871        self.role_external_id = role_external_id if role_external_id is not None else ''
 7872        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 7873        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7874        '''
 7875         ID of the secret store containing credentials for this resource, if any.
 7876        '''
 7877        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7878        '''
 7879         Tags is a map of key, value pairs.
 7880        '''
 7881
 7882    def __repr__(self):
 7883        return '<sdm.NeptuneIAM ' + \
 7884            'access_key: ' + repr(self.access_key) + ' ' +\
 7885            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7886            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7887            'endpoint: ' + repr(self.endpoint) + ' ' +\
 7888            'healthy: ' + repr(self.healthy) + ' ' +\
 7889            'id: ' + repr(self.id) + ' ' +\
 7890            'name: ' + repr(self.name) + ' ' +\
 7891            'port: ' + repr(self.port) + ' ' +\
 7892            'port_override: ' + repr(self.port_override) + ' ' +\
 7893            'region: ' + repr(self.region) + ' ' +\
 7894            'role_arn: ' + repr(self.role_arn) + ' ' +\
 7895            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 7896            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 7897            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7898            'tags: ' + repr(self.tags) + ' ' +\
 7899            '>'
 7900
 7901    def to_dict(self):
 7902        return {
 7903            'access_key': self.access_key,
 7904            'bind_interface': self.bind_interface,
 7905            'egress_filter': self.egress_filter,
 7906            'endpoint': self.endpoint,
 7907            'healthy': self.healthy,
 7908            'id': self.id,
 7909            'name': self.name,
 7910            'port': self.port,
 7911            'port_override': self.port_override,
 7912            'region': self.region,
 7913            'role_arn': self.role_arn,
 7914            'role_external_id': self.role_external_id,
 7915            'secret_access_key': self.secret_access_key,
 7916            'secret_store_id': self.secret_store_id,
 7917            'tags': self.tags,
 7918        }
 7919
 7920    @classmethod
 7921    def from_dict(cls, d):
 7922        return cls(
 7923            access_key=d.get('access_key'),
 7924            bind_interface=d.get('bind_interface'),
 7925            egress_filter=d.get('egress_filter'),
 7926            endpoint=d.get('endpoint'),
 7927            healthy=d.get('healthy'),
 7928            id=d.get('id'),
 7929            name=d.get('name'),
 7930            port=d.get('port'),
 7931            port_override=d.get('port_override'),
 7932            region=d.get('region'),
 7933            role_arn=d.get('role_arn'),
 7934            role_external_id=d.get('role_external_id'),
 7935            secret_access_key=d.get('secret_access_key'),
 7936            secret_store_id=d.get('secret_store_id'),
 7937            tags=d.get('tags'),
 7938        )
 7939
 7940
 7941class NodeCreateResponse:
 7942    '''
 7943         NodeCreateResponse reports how the Nodes were created in the system.
 7944    '''
 7945    __slots__ = [
 7946        'meta',
 7947        'node',
 7948        'rate_limit',
 7949        'token',
 7950    ]
 7951
 7952    def __init__(
 7953        self,
 7954        meta=None,
 7955        node=None,
 7956        rate_limit=None,
 7957        token=None,
 7958    ):
 7959        self.meta = meta if meta is not None else None
 7960        '''
 7961         Reserved for future use.
 7962        '''
 7963        self.node = node if node is not None else None
 7964        '''
 7965         The created Node.
 7966        '''
 7967        self.rate_limit = rate_limit if rate_limit is not None else None
 7968        '''
 7969         Rate limit information.
 7970        '''
 7971        self.token = token if token is not None else ''
 7972        '''
 7973         The auth token generated for the Node. The Node will use this token to
 7974         authenticate with the strongDM API.
 7975        '''
 7976
 7977    def __repr__(self):
 7978        return '<sdm.NodeCreateResponse ' + \
 7979            'meta: ' + repr(self.meta) + ' ' +\
 7980            'node: ' + repr(self.node) + ' ' +\
 7981            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 7982            'token: ' + repr(self.token) + ' ' +\
 7983            '>'
 7984
 7985    def to_dict(self):
 7986        return {
 7987            'meta': self.meta,
 7988            'node': self.node,
 7989            'rate_limit': self.rate_limit,
 7990            'token': self.token,
 7991        }
 7992
 7993    @classmethod
 7994    def from_dict(cls, d):
 7995        return cls(
 7996            meta=d.get('meta'),
 7997            node=d.get('node'),
 7998            rate_limit=d.get('rate_limit'),
 7999            token=d.get('token'),
 8000        )
 8001
 8002
 8003class NodeDeleteResponse:
 8004    '''
 8005         NodeDeleteResponse returns information about a Node that was deleted.
 8006    '''
 8007    __slots__ = [
 8008        'meta',
 8009        'rate_limit',
 8010    ]
 8011
 8012    def __init__(
 8013        self,
 8014        meta=None,
 8015        rate_limit=None,
 8016    ):
 8017        self.meta = meta if meta is not None else None
 8018        '''
 8019         Reserved for future use.
 8020        '''
 8021        self.rate_limit = rate_limit if rate_limit is not None else None
 8022        '''
 8023         Rate limit information.
 8024        '''
 8025
 8026    def __repr__(self):
 8027        return '<sdm.NodeDeleteResponse ' + \
 8028            'meta: ' + repr(self.meta) + ' ' +\
 8029            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8030            '>'
 8031
 8032    def to_dict(self):
 8033        return {
 8034            'meta': self.meta,
 8035            'rate_limit': self.rate_limit,
 8036        }
 8037
 8038    @classmethod
 8039    def from_dict(cls, d):
 8040        return cls(
 8041            meta=d.get('meta'),
 8042            rate_limit=d.get('rate_limit'),
 8043        )
 8044
 8045
 8046class NodeGetResponse:
 8047    '''
 8048         NodeGetResponse returns a requested Node.
 8049    '''
 8050    __slots__ = [
 8051        'meta',
 8052        'node',
 8053        'rate_limit',
 8054    ]
 8055
 8056    def __init__(
 8057        self,
 8058        meta=None,
 8059        node=None,
 8060        rate_limit=None,
 8061    ):
 8062        self.meta = meta if meta is not None else None
 8063        '''
 8064         Reserved for future use.
 8065        '''
 8066        self.node = node if node is not None else None
 8067        '''
 8068         The requested Node.
 8069        '''
 8070        self.rate_limit = rate_limit if rate_limit is not None else None
 8071        '''
 8072         Rate limit information.
 8073        '''
 8074
 8075    def __repr__(self):
 8076        return '<sdm.NodeGetResponse ' + \
 8077            'meta: ' + repr(self.meta) + ' ' +\
 8078            'node: ' + repr(self.node) + ' ' +\
 8079            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8080            '>'
 8081
 8082    def to_dict(self):
 8083        return {
 8084            'meta': self.meta,
 8085            'node': self.node,
 8086            'rate_limit': self.rate_limit,
 8087        }
 8088
 8089    @classmethod
 8090    def from_dict(cls, d):
 8091        return cls(
 8092            meta=d.get('meta'),
 8093            node=d.get('node'),
 8094            rate_limit=d.get('rate_limit'),
 8095        )
 8096
 8097
 8098class NodeUpdateResponse:
 8099    '''
 8100         NodeUpdateResponse returns the fields of a Node after it has been updated by
 8101     a NodeUpdateRequest.
 8102    '''
 8103    __slots__ = [
 8104        'meta',
 8105        'node',
 8106        'rate_limit',
 8107    ]
 8108
 8109    def __init__(
 8110        self,
 8111        meta=None,
 8112        node=None,
 8113        rate_limit=None,
 8114    ):
 8115        self.meta = meta if meta is not None else None
 8116        '''
 8117         Reserved for future use.
 8118        '''
 8119        self.node = node if node is not None else None
 8120        '''
 8121         The updated Node.
 8122        '''
 8123        self.rate_limit = rate_limit if rate_limit is not None else None
 8124        '''
 8125         Rate limit information.
 8126        '''
 8127
 8128    def __repr__(self):
 8129        return '<sdm.NodeUpdateResponse ' + \
 8130            'meta: ' + repr(self.meta) + ' ' +\
 8131            'node: ' + repr(self.node) + ' ' +\
 8132            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8133            '>'
 8134
 8135    def to_dict(self):
 8136        return {
 8137            'meta': self.meta,
 8138            'node': self.node,
 8139            'rate_limit': self.rate_limit,
 8140        }
 8141
 8142    @classmethod
 8143    def from_dict(cls, d):
 8144        return cls(
 8145            meta=d.get('meta'),
 8146            node=d.get('node'),
 8147            rate_limit=d.get('rate_limit'),
 8148        )
 8149
 8150
 8151class Oracle:
 8152    '''
 8153    Oracle is currently unstable, and its API may change, or it may be removed,
 8154    without a major version bump.
 8155    '''
 8156    __slots__ = [
 8157        'bind_interface',
 8158        'database',
 8159        'egress_filter',
 8160        'healthy',
 8161        'hostname',
 8162        'id',
 8163        'name',
 8164        'password',
 8165        'port',
 8166        'port_override',
 8167        'secret_store_id',
 8168        'tags',
 8169        'tls_required',
 8170        'username',
 8171    ]
 8172
 8173    def __init__(
 8174        self,
 8175        bind_interface=None,
 8176        database=None,
 8177        egress_filter=None,
 8178        healthy=None,
 8179        hostname=None,
 8180        id=None,
 8181        name=None,
 8182        password=None,
 8183        port=None,
 8184        port_override=None,
 8185        secret_store_id=None,
 8186        tags=None,
 8187        tls_required=None,
 8188        username=None,
 8189    ):
 8190        self.bind_interface = bind_interface if bind_interface is not None else ''
 8191        '''
 8192         Bind interface
 8193        '''
 8194        self.database = database if database is not None else ''
 8195        self.egress_filter = egress_filter if egress_filter is not None else ''
 8196        '''
 8197         A filter applied to the routing logic to pin datasource to nodes.
 8198        '''
 8199        self.healthy = healthy if healthy is not None else False
 8200        '''
 8201         True if the datasource is reachable and the credentials are valid.
 8202        '''
 8203        self.hostname = hostname if hostname is not None else ''
 8204        self.id = id if id is not None else ''
 8205        '''
 8206         Unique identifier of the Resource.
 8207        '''
 8208        self.name = name if name is not None else ''
 8209        '''
 8210         Unique human-readable name of the Resource.
 8211        '''
 8212        self.password = password if password is not None else ''
 8213        self.port = port if port is not None else 0
 8214        self.port_override = port_override if port_override is not None else 0
 8215        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8216        '''
 8217         ID of the secret store containing credentials for this resource, if any.
 8218        '''
 8219        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8220        '''
 8221         Tags is a map of key, value pairs.
 8222        '''
 8223        self.tls_required = tls_required if tls_required is not None else False
 8224        self.username = username if username is not None else ''
 8225
 8226    def __repr__(self):
 8227        return '<sdm.Oracle ' + \
 8228            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8229            'database: ' + repr(self.database) + ' ' +\
 8230            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8231            'healthy: ' + repr(self.healthy) + ' ' +\
 8232            'hostname: ' + repr(self.hostname) + ' ' +\
 8233            'id: ' + repr(self.id) + ' ' +\
 8234            'name: ' + repr(self.name) + ' ' +\
 8235            'password: ' + repr(self.password) + ' ' +\
 8236            'port: ' + repr(self.port) + ' ' +\
 8237            'port_override: ' + repr(self.port_override) + ' ' +\
 8238            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8239            'tags: ' + repr(self.tags) + ' ' +\
 8240            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8241            'username: ' + repr(self.username) + ' ' +\
 8242            '>'
 8243
 8244    def to_dict(self):
 8245        return {
 8246            'bind_interface': self.bind_interface,
 8247            'database': self.database,
 8248            'egress_filter': self.egress_filter,
 8249            'healthy': self.healthy,
 8250            'hostname': self.hostname,
 8251            'id': self.id,
 8252            'name': self.name,
 8253            'password': self.password,
 8254            'port': self.port,
 8255            'port_override': self.port_override,
 8256            'secret_store_id': self.secret_store_id,
 8257            'tags': self.tags,
 8258            'tls_required': self.tls_required,
 8259            'username': self.username,
 8260        }
 8261
 8262    @classmethod
 8263    def from_dict(cls, d):
 8264        return cls(
 8265            bind_interface=d.get('bind_interface'),
 8266            database=d.get('database'),
 8267            egress_filter=d.get('egress_filter'),
 8268            healthy=d.get('healthy'),
 8269            hostname=d.get('hostname'),
 8270            id=d.get('id'),
 8271            name=d.get('name'),
 8272            password=d.get('password'),
 8273            port=d.get('port'),
 8274            port_override=d.get('port_override'),
 8275            secret_store_id=d.get('secret_store_id'),
 8276            tags=d.get('tags'),
 8277            tls_required=d.get('tls_required'),
 8278            username=d.get('username'),
 8279        )
 8280
 8281
 8282class Postgres:
 8283    __slots__ = [
 8284        'bind_interface',
 8285        'database',
 8286        'egress_filter',
 8287        'healthy',
 8288        'hostname',
 8289        'id',
 8290        'name',
 8291        'override_database',
 8292        'password',
 8293        'port',
 8294        'port_override',
 8295        'secret_store_id',
 8296        'tags',
 8297        'username',
 8298    ]
 8299
 8300    def __init__(
 8301        self,
 8302        bind_interface=None,
 8303        database=None,
 8304        egress_filter=None,
 8305        healthy=None,
 8306        hostname=None,
 8307        id=None,
 8308        name=None,
 8309        override_database=None,
 8310        password=None,
 8311        port=None,
 8312        port_override=None,
 8313        secret_store_id=None,
 8314        tags=None,
 8315        username=None,
 8316    ):
 8317        self.bind_interface = bind_interface if bind_interface is not None else ''
 8318        '''
 8319         Bind interface
 8320        '''
 8321        self.database = database if database is not None else ''
 8322        self.egress_filter = egress_filter if egress_filter is not None else ''
 8323        '''
 8324         A filter applied to the routing logic to pin datasource to nodes.
 8325        '''
 8326        self.healthy = healthy if healthy is not None else False
 8327        '''
 8328         True if the datasource is reachable and the credentials are valid.
 8329        '''
 8330        self.hostname = hostname if hostname is not None else ''
 8331        self.id = id if id is not None else ''
 8332        '''
 8333         Unique identifier of the Resource.
 8334        '''
 8335        self.name = name if name is not None else ''
 8336        '''
 8337         Unique human-readable name of the Resource.
 8338        '''
 8339        self.override_database = override_database if override_database is not None else False
 8340        self.password = password if password is not None else ''
 8341        self.port = port if port is not None else 0
 8342        self.port_override = port_override if port_override is not None else 0
 8343        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8344        '''
 8345         ID of the secret store containing credentials for this resource, if any.
 8346        '''
 8347        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8348        '''
 8349         Tags is a map of key, value pairs.
 8350        '''
 8351        self.username = username if username is not None else ''
 8352
 8353    def __repr__(self):
 8354        return '<sdm.Postgres ' + \
 8355            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8356            'database: ' + repr(self.database) + ' ' +\
 8357            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8358            'healthy: ' + repr(self.healthy) + ' ' +\
 8359            'hostname: ' + repr(self.hostname) + ' ' +\
 8360            'id: ' + repr(self.id) + ' ' +\
 8361            'name: ' + repr(self.name) + ' ' +\
 8362            'override_database: ' + repr(self.override_database) + ' ' +\
 8363            'password: ' + repr(self.password) + ' ' +\
 8364            'port: ' + repr(self.port) + ' ' +\
 8365            'port_override: ' + repr(self.port_override) + ' ' +\
 8366            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8367            'tags: ' + repr(self.tags) + ' ' +\
 8368            'username: ' + repr(self.username) + ' ' +\
 8369            '>'
 8370
 8371    def to_dict(self):
 8372        return {
 8373            'bind_interface': self.bind_interface,
 8374            'database': self.database,
 8375            'egress_filter': self.egress_filter,
 8376            'healthy': self.healthy,
 8377            'hostname': self.hostname,
 8378            'id': self.id,
 8379            'name': self.name,
 8380            'override_database': self.override_database,
 8381            'password': self.password,
 8382            'port': self.port,
 8383            'port_override': self.port_override,
 8384            'secret_store_id': self.secret_store_id,
 8385            'tags': self.tags,
 8386            'username': self.username,
 8387        }
 8388
 8389    @classmethod
 8390    def from_dict(cls, d):
 8391        return cls(
 8392            bind_interface=d.get('bind_interface'),
 8393            database=d.get('database'),
 8394            egress_filter=d.get('egress_filter'),
 8395            healthy=d.get('healthy'),
 8396            hostname=d.get('hostname'),
 8397            id=d.get('id'),
 8398            name=d.get('name'),
 8399            override_database=d.get('override_database'),
 8400            password=d.get('password'),
 8401            port=d.get('port'),
 8402            port_override=d.get('port_override'),
 8403            secret_store_id=d.get('secret_store_id'),
 8404            tags=d.get('tags'),
 8405            username=d.get('username'),
 8406        )
 8407
 8408
 8409class Presto:
 8410    __slots__ = [
 8411        'bind_interface',
 8412        'database',
 8413        'egress_filter',
 8414        'healthy',
 8415        'hostname',
 8416        'id',
 8417        'name',
 8418        'password',
 8419        'port',
 8420        'port_override',
 8421        'secret_store_id',
 8422        'tags',
 8423        'tls_required',
 8424        'username',
 8425    ]
 8426
 8427    def __init__(
 8428        self,
 8429        bind_interface=None,
 8430        database=None,
 8431        egress_filter=None,
 8432        healthy=None,
 8433        hostname=None,
 8434        id=None,
 8435        name=None,
 8436        password=None,
 8437        port=None,
 8438        port_override=None,
 8439        secret_store_id=None,
 8440        tags=None,
 8441        tls_required=None,
 8442        username=None,
 8443    ):
 8444        self.bind_interface = bind_interface if bind_interface is not None else ''
 8445        '''
 8446         Bind interface
 8447        '''
 8448        self.database = database if database is not None else ''
 8449        self.egress_filter = egress_filter if egress_filter is not None else ''
 8450        '''
 8451         A filter applied to the routing logic to pin datasource to nodes.
 8452        '''
 8453        self.healthy = healthy if healthy is not None else False
 8454        '''
 8455         True if the datasource is reachable and the credentials are valid.
 8456        '''
 8457        self.hostname = hostname if hostname is not None else ''
 8458        self.id = id if id is not None else ''
 8459        '''
 8460         Unique identifier of the Resource.
 8461        '''
 8462        self.name = name if name is not None else ''
 8463        '''
 8464         Unique human-readable name of the Resource.
 8465        '''
 8466        self.password = password if password is not None else ''
 8467        self.port = port if port is not None else 0
 8468        self.port_override = port_override if port_override is not None else 0
 8469        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8470        '''
 8471         ID of the secret store containing credentials for this resource, if any.
 8472        '''
 8473        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8474        '''
 8475         Tags is a map of key, value pairs.
 8476        '''
 8477        self.tls_required = tls_required if tls_required is not None else False
 8478        self.username = username if username is not None else ''
 8479
 8480    def __repr__(self):
 8481        return '<sdm.Presto ' + \
 8482            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8483            'database: ' + repr(self.database) + ' ' +\
 8484            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8485            'healthy: ' + repr(self.healthy) + ' ' +\
 8486            'hostname: ' + repr(self.hostname) + ' ' +\
 8487            'id: ' + repr(self.id) + ' ' +\
 8488            'name: ' + repr(self.name) + ' ' +\
 8489            'password: ' + repr(self.password) + ' ' +\
 8490            'port: ' + repr(self.port) + ' ' +\
 8491            'port_override: ' + repr(self.port_override) + ' ' +\
 8492            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8493            'tags: ' + repr(self.tags) + ' ' +\
 8494            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8495            'username: ' + repr(self.username) + ' ' +\
 8496            '>'
 8497
 8498    def to_dict(self):
 8499        return {
 8500            'bind_interface': self.bind_interface,
 8501            'database': self.database,
 8502            'egress_filter': self.egress_filter,
 8503            'healthy': self.healthy,
 8504            'hostname': self.hostname,
 8505            'id': self.id,
 8506            'name': self.name,
 8507            'password': self.password,
 8508            'port': self.port,
 8509            'port_override': self.port_override,
 8510            'secret_store_id': self.secret_store_id,
 8511            'tags': self.tags,
 8512            'tls_required': self.tls_required,
 8513            'username': self.username,
 8514        }
 8515
 8516    @classmethod
 8517    def from_dict(cls, d):
 8518        return cls(
 8519            bind_interface=d.get('bind_interface'),
 8520            database=d.get('database'),
 8521            egress_filter=d.get('egress_filter'),
 8522            healthy=d.get('healthy'),
 8523            hostname=d.get('hostname'),
 8524            id=d.get('id'),
 8525            name=d.get('name'),
 8526            password=d.get('password'),
 8527            port=d.get('port'),
 8528            port_override=d.get('port_override'),
 8529            secret_store_id=d.get('secret_store_id'),
 8530            tags=d.get('tags'),
 8531            tls_required=d.get('tls_required'),
 8532            username=d.get('username'),
 8533        )
 8534
 8535
 8536class RDP:
 8537    __slots__ = [
 8538        'bind_interface',
 8539        'downgrade_nla_connections',
 8540        'egress_filter',
 8541        'healthy',
 8542        'hostname',
 8543        'id',
 8544        'name',
 8545        'password',
 8546        'port',
 8547        'port_override',
 8548        'secret_store_id',
 8549        'tags',
 8550        'username',
 8551    ]
 8552
 8553    def __init__(
 8554        self,
 8555        bind_interface=None,
 8556        downgrade_nla_connections=None,
 8557        egress_filter=None,
 8558        healthy=None,
 8559        hostname=None,
 8560        id=None,
 8561        name=None,
 8562        password=None,
 8563        port=None,
 8564        port_override=None,
 8565        secret_store_id=None,
 8566        tags=None,
 8567        username=None,
 8568    ):
 8569        self.bind_interface = bind_interface if bind_interface is not None else ''
 8570        '''
 8571         Bind interface
 8572        '''
 8573        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 8574        self.egress_filter = egress_filter if egress_filter is not None else ''
 8575        '''
 8576         A filter applied to the routing logic to pin datasource to nodes.
 8577        '''
 8578        self.healthy = healthy if healthy is not None else False
 8579        '''
 8580         True if the datasource is reachable and the credentials are valid.
 8581        '''
 8582        self.hostname = hostname if hostname is not None else ''
 8583        self.id = id if id is not None else ''
 8584        '''
 8585         Unique identifier of the Resource.
 8586        '''
 8587        self.name = name if name is not None else ''
 8588        '''
 8589         Unique human-readable name of the Resource.
 8590        '''
 8591        self.password = password if password is not None else ''
 8592        self.port = port if port is not None else 0
 8593        self.port_override = port_override if port_override is not None else 0
 8594        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8595        '''
 8596         ID of the secret store containing credentials for this resource, if any.
 8597        '''
 8598        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8599        '''
 8600         Tags is a map of key, value pairs.
 8601        '''
 8602        self.username = username if username is not None else ''
 8603
 8604    def __repr__(self):
 8605        return '<sdm.RDP ' + \
 8606            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8607            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 8608            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8609            'healthy: ' + repr(self.healthy) + ' ' +\
 8610            'hostname: ' + repr(self.hostname) + ' ' +\
 8611            'id: ' + repr(self.id) + ' ' +\
 8612            'name: ' + repr(self.name) + ' ' +\
 8613            'password: ' + repr(self.password) + ' ' +\
 8614            'port: ' + repr(self.port) + ' ' +\
 8615            'port_override: ' + repr(self.port_override) + ' ' +\
 8616            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8617            'tags: ' + repr(self.tags) + ' ' +\
 8618            'username: ' + repr(self.username) + ' ' +\
 8619            '>'
 8620
 8621    def to_dict(self):
 8622        return {
 8623            'bind_interface': self.bind_interface,
 8624            'downgrade_nla_connections': self.downgrade_nla_connections,
 8625            'egress_filter': self.egress_filter,
 8626            'healthy': self.healthy,
 8627            'hostname': self.hostname,
 8628            'id': self.id,
 8629            'name': self.name,
 8630            'password': self.password,
 8631            'port': self.port,
 8632            'port_override': self.port_override,
 8633            'secret_store_id': self.secret_store_id,
 8634            'tags': self.tags,
 8635            'username': self.username,
 8636        }
 8637
 8638    @classmethod
 8639    def from_dict(cls, d):
 8640        return cls(
 8641            bind_interface=d.get('bind_interface'),
 8642            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 8643            egress_filter=d.get('egress_filter'),
 8644            healthy=d.get('healthy'),
 8645            hostname=d.get('hostname'),
 8646            id=d.get('id'),
 8647            name=d.get('name'),
 8648            password=d.get('password'),
 8649            port=d.get('port'),
 8650            port_override=d.get('port_override'),
 8651            secret_store_id=d.get('secret_store_id'),
 8652            tags=d.get('tags'),
 8653            username=d.get('username'),
 8654        )
 8655
 8656
 8657class RabbitMQAMQP091:
 8658    __slots__ = [
 8659        'bind_interface',
 8660        'egress_filter',
 8661        'healthy',
 8662        'hostname',
 8663        'id',
 8664        'name',
 8665        'password',
 8666        'port',
 8667        'port_override',
 8668        'secret_store_id',
 8669        'tags',
 8670        'tls_required',
 8671        'username',
 8672    ]
 8673
 8674    def __init__(
 8675        self,
 8676        bind_interface=None,
 8677        egress_filter=None,
 8678        healthy=None,
 8679        hostname=None,
 8680        id=None,
 8681        name=None,
 8682        password=None,
 8683        port=None,
 8684        port_override=None,
 8685        secret_store_id=None,
 8686        tags=None,
 8687        tls_required=None,
 8688        username=None,
 8689    ):
 8690        self.bind_interface = bind_interface if bind_interface is not None else ''
 8691        '''
 8692         Bind interface
 8693        '''
 8694        self.egress_filter = egress_filter if egress_filter is not None else ''
 8695        '''
 8696         A filter applied to the routing logic to pin datasource to nodes.
 8697        '''
 8698        self.healthy = healthy if healthy is not None else False
 8699        '''
 8700         True if the datasource is reachable and the credentials are valid.
 8701        '''
 8702        self.hostname = hostname if hostname is not None else ''
 8703        self.id = id if id is not None else ''
 8704        '''
 8705         Unique identifier of the Resource.
 8706        '''
 8707        self.name = name if name is not None else ''
 8708        '''
 8709         Unique human-readable name of the Resource.
 8710        '''
 8711        self.password = password if password is not None else ''
 8712        self.port = port if port is not None else 0
 8713        self.port_override = port_override if port_override is not None else 0
 8714        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8715        '''
 8716         ID of the secret store containing credentials for this resource, if any.
 8717        '''
 8718        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8719        '''
 8720         Tags is a map of key, value pairs.
 8721        '''
 8722        self.tls_required = tls_required if tls_required is not None else False
 8723        self.username = username if username is not None else ''
 8724
 8725    def __repr__(self):
 8726        return '<sdm.RabbitMQAMQP091 ' + \
 8727            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8728            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8729            'healthy: ' + repr(self.healthy) + ' ' +\
 8730            'hostname: ' + repr(self.hostname) + ' ' +\
 8731            'id: ' + repr(self.id) + ' ' +\
 8732            'name: ' + repr(self.name) + ' ' +\
 8733            'password: ' + repr(self.password) + ' ' +\
 8734            'port: ' + repr(self.port) + ' ' +\
 8735            'port_override: ' + repr(self.port_override) + ' ' +\
 8736            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8737            'tags: ' + repr(self.tags) + ' ' +\
 8738            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8739            'username: ' + repr(self.username) + ' ' +\
 8740            '>'
 8741
 8742    def to_dict(self):
 8743        return {
 8744            'bind_interface': self.bind_interface,
 8745            'egress_filter': self.egress_filter,
 8746            'healthy': self.healthy,
 8747            'hostname': self.hostname,
 8748            'id': self.id,
 8749            'name': self.name,
 8750            'password': self.password,
 8751            'port': self.port,
 8752            'port_override': self.port_override,
 8753            'secret_store_id': self.secret_store_id,
 8754            'tags': self.tags,
 8755            'tls_required': self.tls_required,
 8756            'username': self.username,
 8757        }
 8758
 8759    @classmethod
 8760    def from_dict(cls, d):
 8761        return cls(
 8762            bind_interface=d.get('bind_interface'),
 8763            egress_filter=d.get('egress_filter'),
 8764            healthy=d.get('healthy'),
 8765            hostname=d.get('hostname'),
 8766            id=d.get('id'),
 8767            name=d.get('name'),
 8768            password=d.get('password'),
 8769            port=d.get('port'),
 8770            port_override=d.get('port_override'),
 8771            secret_store_id=d.get('secret_store_id'),
 8772            tags=d.get('tags'),
 8773            tls_required=d.get('tls_required'),
 8774            username=d.get('username'),
 8775        )
 8776
 8777
 8778class RateLimitMetadata:
 8779    '''
 8780         RateLimitMetadata contains information about remaining requests avaialable
 8781     to the user over some timeframe.
 8782    '''
 8783    __slots__ = [
 8784        'bucket',
 8785        'limit',
 8786        'remaining',
 8787        'reset_at',
 8788    ]
 8789
 8790    def __init__(
 8791        self,
 8792        bucket=None,
 8793        limit=None,
 8794        remaining=None,
 8795        reset_at=None,
 8796    ):
 8797        self.bucket = bucket if bucket is not None else ''
 8798        '''
 8799         The bucket this user/token is associated with, which may be shared between
 8800         multiple users/tokens.
 8801        '''
 8802        self.limit = limit if limit is not None else 0
 8803        '''
 8804         How many total requests the user/token is authorized to make before being
 8805         rate limited.
 8806        '''
 8807        self.remaining = remaining if remaining is not None else 0
 8808        '''
 8809         How many remaining requests out of the limit are still avaialable.
 8810        '''
 8811        self.reset_at = reset_at if reset_at is not None else None
 8812        '''
 8813         The time when remaining will be reset to limit.
 8814        '''
 8815
 8816    def __repr__(self):
 8817        return '<sdm.RateLimitMetadata ' + \
 8818            'bucket: ' + repr(self.bucket) + ' ' +\
 8819            'limit: ' + repr(self.limit) + ' ' +\
 8820            'remaining: ' + repr(self.remaining) + ' ' +\
 8821            'reset_at: ' + repr(self.reset_at) + ' ' +\
 8822            '>'
 8823
 8824    def to_dict(self):
 8825        return {
 8826            'bucket': self.bucket,
 8827            'limit': self.limit,
 8828            'remaining': self.remaining,
 8829            'reset_at': self.reset_at,
 8830        }
 8831
 8832    @classmethod
 8833    def from_dict(cls, d):
 8834        return cls(
 8835            bucket=d.get('bucket'),
 8836            limit=d.get('limit'),
 8837            remaining=d.get('remaining'),
 8838            reset_at=d.get('reset_at'),
 8839        )
 8840
 8841
 8842class RawTCP:
 8843    __slots__ = [
 8844        'bind_interface',
 8845        'egress_filter',
 8846        'healthy',
 8847        'hostname',
 8848        'id',
 8849        'name',
 8850        'port',
 8851        'port_override',
 8852        'secret_store_id',
 8853        'tags',
 8854    ]
 8855
 8856    def __init__(
 8857        self,
 8858        bind_interface=None,
 8859        egress_filter=None,
 8860        healthy=None,
 8861        hostname=None,
 8862        id=None,
 8863        name=None,
 8864        port=None,
 8865        port_override=None,
 8866        secret_store_id=None,
 8867        tags=None,
 8868    ):
 8869        self.bind_interface = bind_interface if bind_interface is not None else ''
 8870        '''
 8871         Bind interface
 8872        '''
 8873        self.egress_filter = egress_filter if egress_filter is not None else ''
 8874        '''
 8875         A filter applied to the routing logic to pin datasource to nodes.
 8876        '''
 8877        self.healthy = healthy if healthy is not None else False
 8878        '''
 8879         True if the datasource is reachable and the credentials are valid.
 8880        '''
 8881        self.hostname = hostname if hostname is not None else ''
 8882        self.id = id if id is not None else ''
 8883        '''
 8884         Unique identifier of the Resource.
 8885        '''
 8886        self.name = name if name is not None else ''
 8887        '''
 8888         Unique human-readable name of the Resource.
 8889        '''
 8890        self.port = port if port is not None else 0
 8891        self.port_override = port_override if port_override is not None else 0
 8892        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8893        '''
 8894         ID of the secret store containing credentials for this resource, if any.
 8895        '''
 8896        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8897        '''
 8898         Tags is a map of key, value pairs.
 8899        '''
 8900
 8901    def __repr__(self):
 8902        return '<sdm.RawTCP ' + \
 8903            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8904            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8905            'healthy: ' + repr(self.healthy) + ' ' +\
 8906            'hostname: ' + repr(self.hostname) + ' ' +\
 8907            'id: ' + repr(self.id) + ' ' +\
 8908            'name: ' + repr(self.name) + ' ' +\
 8909            'port: ' + repr(self.port) + ' ' +\
 8910            'port_override: ' + repr(self.port_override) + ' ' +\
 8911            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8912            'tags: ' + repr(self.tags) + ' ' +\
 8913            '>'
 8914
 8915    def to_dict(self):
 8916        return {
 8917            'bind_interface': self.bind_interface,
 8918            'egress_filter': self.egress_filter,
 8919            'healthy': self.healthy,
 8920            'hostname': self.hostname,
 8921            'id': self.id,
 8922            'name': self.name,
 8923            'port': self.port,
 8924            'port_override': self.port_override,
 8925            'secret_store_id': self.secret_store_id,
 8926            'tags': self.tags,
 8927        }
 8928
 8929    @classmethod
 8930    def from_dict(cls, d):
 8931        return cls(
 8932            bind_interface=d.get('bind_interface'),
 8933            egress_filter=d.get('egress_filter'),
 8934            healthy=d.get('healthy'),
 8935            hostname=d.get('hostname'),
 8936            id=d.get('id'),
 8937            name=d.get('name'),
 8938            port=d.get('port'),
 8939            port_override=d.get('port_override'),
 8940            secret_store_id=d.get('secret_store_id'),
 8941            tags=d.get('tags'),
 8942        )
 8943
 8944
 8945class Redis:
 8946    __slots__ = [
 8947        'bind_interface',
 8948        'egress_filter',
 8949        'healthy',
 8950        'hostname',
 8951        'id',
 8952        'name',
 8953        'password',
 8954        'port',
 8955        'port_override',
 8956        'secret_store_id',
 8957        'tags',
 8958    ]
 8959
 8960    def __init__(
 8961        self,
 8962        bind_interface=None,
 8963        egress_filter=None,
 8964        healthy=None,
 8965        hostname=None,
 8966        id=None,
 8967        name=None,
 8968        password=None,
 8969        port=None,
 8970        port_override=None,
 8971        secret_store_id=None,
 8972        tags=None,
 8973    ):
 8974        self.bind_interface = bind_interface if bind_interface is not None else ''
 8975        '''
 8976         Bind interface
 8977        '''
 8978        self.egress_filter = egress_filter if egress_filter is not None else ''
 8979        '''
 8980         A filter applied to the routing logic to pin datasource to nodes.
 8981        '''
 8982        self.healthy = healthy if healthy is not None else False
 8983        '''
 8984         True if the datasource is reachable and the credentials are valid.
 8985        '''
 8986        self.hostname = hostname if hostname is not None else ''
 8987        self.id = id if id is not None else ''
 8988        '''
 8989         Unique identifier of the Resource.
 8990        '''
 8991        self.name = name if name is not None else ''
 8992        '''
 8993         Unique human-readable name of the Resource.
 8994        '''
 8995        self.password = password if password is not None else ''
 8996        self.port = port if port is not None else 0
 8997        self.port_override = port_override if port_override is not None else 0
 8998        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8999        '''
 9000         ID of the secret store containing credentials for this resource, if any.
 9001        '''
 9002        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9003        '''
 9004         Tags is a map of key, value pairs.
 9005        '''
 9006
 9007    def __repr__(self):
 9008        return '<sdm.Redis ' + \
 9009            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9010            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9011            'healthy: ' + repr(self.healthy) + ' ' +\
 9012            'hostname: ' + repr(self.hostname) + ' ' +\
 9013            'id: ' + repr(self.id) + ' ' +\
 9014            'name: ' + repr(self.name) + ' ' +\
 9015            'password: ' + repr(self.password) + ' ' +\
 9016            'port: ' + repr(self.port) + ' ' +\
 9017            'port_override: ' + repr(self.port_override) + ' ' +\
 9018            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9019            'tags: ' + repr(self.tags) + ' ' +\
 9020            '>'
 9021
 9022    def to_dict(self):
 9023        return {
 9024            'bind_interface': self.bind_interface,
 9025            'egress_filter': self.egress_filter,
 9026            'healthy': self.healthy,
 9027            'hostname': self.hostname,
 9028            'id': self.id,
 9029            'name': self.name,
 9030            'password': self.password,
 9031            'port': self.port,
 9032            'port_override': self.port_override,
 9033            'secret_store_id': self.secret_store_id,
 9034            'tags': self.tags,
 9035        }
 9036
 9037    @classmethod
 9038    def from_dict(cls, d):
 9039        return cls(
 9040            bind_interface=d.get('bind_interface'),
 9041            egress_filter=d.get('egress_filter'),
 9042            healthy=d.get('healthy'),
 9043            hostname=d.get('hostname'),
 9044            id=d.get('id'),
 9045            name=d.get('name'),
 9046            password=d.get('password'),
 9047            port=d.get('port'),
 9048            port_override=d.get('port_override'),
 9049            secret_store_id=d.get('secret_store_id'),
 9050            tags=d.get('tags'),
 9051        )
 9052
 9053
 9054class Redshift:
 9055    __slots__ = [
 9056        'bind_interface',
 9057        'database',
 9058        'egress_filter',
 9059        'healthy',
 9060        'hostname',
 9061        'id',
 9062        'name',
 9063        'override_database',
 9064        'password',
 9065        'port',
 9066        'port_override',
 9067        'secret_store_id',
 9068        'tags',
 9069        'username',
 9070    ]
 9071
 9072    def __init__(
 9073        self,
 9074        bind_interface=None,
 9075        database=None,
 9076        egress_filter=None,
 9077        healthy=None,
 9078        hostname=None,
 9079        id=None,
 9080        name=None,
 9081        override_database=None,
 9082        password=None,
 9083        port=None,
 9084        port_override=None,
 9085        secret_store_id=None,
 9086        tags=None,
 9087        username=None,
 9088    ):
 9089        self.bind_interface = bind_interface if bind_interface is not None else ''
 9090        '''
 9091         Bind interface
 9092        '''
 9093        self.database = database if database is not None else ''
 9094        self.egress_filter = egress_filter if egress_filter is not None else ''
 9095        '''
 9096         A filter applied to the routing logic to pin datasource to nodes.
 9097        '''
 9098        self.healthy = healthy if healthy is not None else False
 9099        '''
 9100         True if the datasource is reachable and the credentials are valid.
 9101        '''
 9102        self.hostname = hostname if hostname is not None else ''
 9103        self.id = id if id is not None else ''
 9104        '''
 9105         Unique identifier of the Resource.
 9106        '''
 9107        self.name = name if name is not None else ''
 9108        '''
 9109         Unique human-readable name of the Resource.
 9110        '''
 9111        self.override_database = override_database if override_database is not None else False
 9112        self.password = password if password is not None else ''
 9113        self.port = port if port is not None else 0
 9114        self.port_override = port_override if port_override is not None else 0
 9115        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9116        '''
 9117         ID of the secret store containing credentials for this resource, if any.
 9118        '''
 9119        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9120        '''
 9121         Tags is a map of key, value pairs.
 9122        '''
 9123        self.username = username if username is not None else ''
 9124
 9125    def __repr__(self):
 9126        return '<sdm.Redshift ' + \
 9127            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9128            'database: ' + repr(self.database) + ' ' +\
 9129            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9130            'healthy: ' + repr(self.healthy) + ' ' +\
 9131            'hostname: ' + repr(self.hostname) + ' ' +\
 9132            'id: ' + repr(self.id) + ' ' +\
 9133            'name: ' + repr(self.name) + ' ' +\
 9134            'override_database: ' + repr(self.override_database) + ' ' +\
 9135            'password: ' + repr(self.password) + ' ' +\
 9136            'port: ' + repr(self.port) + ' ' +\
 9137            'port_override: ' + repr(self.port_override) + ' ' +\
 9138            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9139            'tags: ' + repr(self.tags) + ' ' +\
 9140            'username: ' + repr(self.username) + ' ' +\
 9141            '>'
 9142
 9143    def to_dict(self):
 9144        return {
 9145            'bind_interface': self.bind_interface,
 9146            'database': self.database,
 9147            'egress_filter': self.egress_filter,
 9148            'healthy': self.healthy,
 9149            'hostname': self.hostname,
 9150            'id': self.id,
 9151            'name': self.name,
 9152            'override_database': self.override_database,
 9153            'password': self.password,
 9154            'port': self.port,
 9155            'port_override': self.port_override,
 9156            'secret_store_id': self.secret_store_id,
 9157            'tags': self.tags,
 9158            'username': self.username,
 9159        }
 9160
 9161    @classmethod
 9162    def from_dict(cls, d):
 9163        return cls(
 9164            bind_interface=d.get('bind_interface'),
 9165            database=d.get('database'),
 9166            egress_filter=d.get('egress_filter'),
 9167            healthy=d.get('healthy'),
 9168            hostname=d.get('hostname'),
 9169            id=d.get('id'),
 9170            name=d.get('name'),
 9171            override_database=d.get('override_database'),
 9172            password=d.get('password'),
 9173            port=d.get('port'),
 9174            port_override=d.get('port_override'),
 9175            secret_store_id=d.get('secret_store_id'),
 9176            tags=d.get('tags'),
 9177            username=d.get('username'),
 9178        )
 9179
 9180
 9181class Relay:
 9182    '''
 9183         Relay represents a StrongDM CLI installation running in relay mode.
 9184    '''
 9185    __slots__ = [
 9186        'gateway_filter',
 9187        'id',
 9188        'name',
 9189        'state',
 9190        'tags',
 9191    ]
 9192
 9193    def __init__(
 9194        self,
 9195        gateway_filter=None,
 9196        id=None,
 9197        name=None,
 9198        state=None,
 9199        tags=None,
 9200    ):
 9201        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 9202        '''
 9203         GatewayFilter can be used to restrict the peering between relays and
 9204         gateways.
 9205        '''
 9206        self.id = id if id is not None else ''
 9207        '''
 9208         Unique identifier of the Relay.
 9209        '''
 9210        self.name = name if name is not None else ''
 9211        '''
 9212         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 9213        '''
 9214        self.state = state if state is not None else ''
 9215        '''
 9216         The current state of the relay. One of: "new", "verifying_restart",
 9217         "awaiting_restart", "restarting", "started", "stopped", "dead",
 9218         "unknown".
 9219        '''
 9220        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9221        '''
 9222         Tags is a map of key, value pairs.
 9223        '''
 9224
 9225    def __repr__(self):
 9226        return '<sdm.Relay ' + \
 9227            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 9228            'id: ' + repr(self.id) + ' ' +\
 9229            'name: ' + repr(self.name) + ' ' +\
 9230            'state: ' + repr(self.state) + ' ' +\
 9231            'tags: ' + repr(self.tags) + ' ' +\
 9232            '>'
 9233
 9234    def to_dict(self):
 9235        return {
 9236            'gateway_filter': self.gateway_filter,
 9237            'id': self.id,
 9238            'name': self.name,
 9239            'state': self.state,
 9240            'tags': self.tags,
 9241        }
 9242
 9243    @classmethod
 9244    def from_dict(cls, d):
 9245        return cls(
 9246            gateway_filter=d.get('gateway_filter'),
 9247            id=d.get('id'),
 9248            name=d.get('name'),
 9249            state=d.get('state'),
 9250            tags=d.get('tags'),
 9251        )
 9252
 9253
 9254class RemoteIdentity:
 9255    '''
 9256         RemoteIdentities define the username to be used for a specific account
 9257     when connecting to a remote resource using that group.
 9258    '''
 9259    __slots__ = [
 9260        'account_id',
 9261        'id',
 9262        'remote_identity_group_id',
 9263        'username',
 9264    ]
 9265
 9266    def __init__(
 9267        self,
 9268        account_id=None,
 9269        id=None,
 9270        remote_identity_group_id=None,
 9271        username=None,
 9272    ):
 9273        self.account_id = account_id if account_id is not None else ''
 9274        '''
 9275         The account for this remote identity.
 9276        '''
 9277        self.id = id if id is not None else ''
 9278        '''
 9279         Unique identifier of the RemoteIdentity.
 9280        '''
 9281        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 9282        '''
 9283         The remote identity group.
 9284        '''
 9285        self.username = username if username is not None else ''
 9286        '''
 9287         The username to be used as the remote identity for this account.
 9288        '''
 9289
 9290    def __repr__(self):
 9291        return '<sdm.RemoteIdentity ' + \
 9292            'account_id: ' + repr(self.account_id) + ' ' +\
 9293            'id: ' + repr(self.id) + ' ' +\
 9294            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 9295            'username: ' + repr(self.username) + ' ' +\
 9296            '>'
 9297
 9298    def to_dict(self):
 9299        return {
 9300            'account_id': self.account_id,
 9301            'id': self.id,
 9302            'remote_identity_group_id': self.remote_identity_group_id,
 9303            'username': self.username,
 9304        }
 9305
 9306    @classmethod
 9307    def from_dict(cls, d):
 9308        return cls(
 9309            account_id=d.get('account_id'),
 9310            id=d.get('id'),
 9311            remote_identity_group_id=d.get('remote_identity_group_id'),
 9312            username=d.get('username'),
 9313        )
 9314
 9315
 9316class RemoteIdentityCreateResponse:
 9317    '''
 9318         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
 9319    '''
 9320    __slots__ = [
 9321        'meta',
 9322        'rate_limit',
 9323        'remote_identity',
 9324    ]
 9325
 9326    def __init__(
 9327        self,
 9328        meta=None,
 9329        rate_limit=None,
 9330        remote_identity=None,
 9331    ):
 9332        self.meta = meta if meta is not None else None
 9333        '''
 9334         Reserved for future use.
 9335        '''
 9336        self.rate_limit = rate_limit if rate_limit is not None else None
 9337        '''
 9338         Rate limit information.
 9339        '''
 9340        self.remote_identity = remote_identity if remote_identity is not None else None
 9341        '''
 9342         The created RemoteIdentity.
 9343        '''
 9344
 9345    def __repr__(self):
 9346        return '<sdm.RemoteIdentityCreateResponse ' + \
 9347            'meta: ' + repr(self.meta) + ' ' +\
 9348            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9349            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9350            '>'
 9351
 9352    def to_dict(self):
 9353        return {
 9354            'meta': self.meta,
 9355            'rate_limit': self.rate_limit,
 9356            'remote_identity': self.remote_identity,
 9357        }
 9358
 9359    @classmethod
 9360    def from_dict(cls, d):
 9361        return cls(
 9362            meta=d.get('meta'),
 9363            rate_limit=d.get('rate_limit'),
 9364            remote_identity=d.get('remote_identity'),
 9365        )
 9366
 9367
 9368class RemoteIdentityDeleteResponse:
 9369    '''
 9370         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
 9371    '''
 9372    __slots__ = [
 9373        'meta',
 9374        'rate_limit',
 9375    ]
 9376
 9377    def __init__(
 9378        self,
 9379        meta=None,
 9380        rate_limit=None,
 9381    ):
 9382        self.meta = meta if meta is not None else None
 9383        '''
 9384         Reserved for future use.
 9385        '''
 9386        self.rate_limit = rate_limit if rate_limit is not None else None
 9387        '''
 9388         Rate limit information.
 9389        '''
 9390
 9391    def __repr__(self):
 9392        return '<sdm.RemoteIdentityDeleteResponse ' + \
 9393            'meta: ' + repr(self.meta) + ' ' +\
 9394            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9395            '>'
 9396
 9397    def to_dict(self):
 9398        return {
 9399            'meta': self.meta,
 9400            'rate_limit': self.rate_limit,
 9401        }
 9402
 9403    @classmethod
 9404    def from_dict(cls, d):
 9405        return cls(
 9406            meta=d.get('meta'),
 9407            rate_limit=d.get('rate_limit'),
 9408        )
 9409
 9410
 9411class RemoteIdentityGetResponse:
 9412    '''
 9413         RemoteIdentityGetResponse returns a requested RemoteIdentity.
 9414    '''
 9415    __slots__ = [
 9416        'meta',
 9417        'rate_limit',
 9418        'remote_identity',
 9419    ]
 9420
 9421    def __init__(
 9422        self,
 9423        meta=None,
 9424        rate_limit=None,
 9425        remote_identity=None,
 9426    ):
 9427        self.meta = meta if meta is not None else None
 9428        '''
 9429         Reserved for future use.
 9430        '''
 9431        self.rate_limit = rate_limit if rate_limit is not None else None
 9432        '''
 9433         Rate limit information.
 9434        '''
 9435        self.remote_identity = remote_identity if remote_identity is not None else None
 9436        '''
 9437         The requested RemoteIdentity.
 9438        '''
 9439
 9440    def __repr__(self):
 9441        return '<sdm.RemoteIdentityGetResponse ' + \
 9442            'meta: ' + repr(self.meta) + ' ' +\
 9443            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9444            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9445            '>'
 9446
 9447    def to_dict(self):
 9448        return {
 9449            'meta': self.meta,
 9450            'rate_limit': self.rate_limit,
 9451            'remote_identity': self.remote_identity,
 9452        }
 9453
 9454    @classmethod
 9455    def from_dict(cls, d):
 9456        return cls(
 9457            meta=d.get('meta'),
 9458            rate_limit=d.get('rate_limit'),
 9459            remote_identity=d.get('remote_identity'),
 9460        )
 9461
 9462
 9463class RemoteIdentityGroup:
 9464    '''
 9465         A RemoteIdentityGroup defines a group of remote identities.
 9466    '''
 9467    __slots__ = [
 9468        'id',
 9469        'name',
 9470    ]
 9471
 9472    def __init__(
 9473        self,
 9474        id=None,
 9475        name=None,
 9476    ):
 9477        self.id = id if id is not None else ''
 9478        '''
 9479         Unique identifier of the RemoteIdentityGroup.
 9480        '''
 9481        self.name = name if name is not None else ''
 9482        '''
 9483         Unique human-readable name of the RemoteIdentityGroup.
 9484        '''
 9485
 9486    def __repr__(self):
 9487        return '<sdm.RemoteIdentityGroup ' + \
 9488            'id: ' + repr(self.id) + ' ' +\
 9489            'name: ' + repr(self.name) + ' ' +\
 9490            '>'
 9491
 9492    def to_dict(self):
 9493        return {
 9494            'id': self.id,
 9495            'name': self.name,
 9496        }
 9497
 9498    @classmethod
 9499    def from_dict(cls, d):
 9500        return cls(
 9501            id=d.get('id'),
 9502            name=d.get('name'),
 9503        )
 9504
 9505
 9506class RemoteIdentityGroupGetResponse:
 9507    '''
 9508         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
 9509    '''
 9510    __slots__ = [
 9511        'meta',
 9512        'rate_limit',
 9513        'remote_identity_group',
 9514    ]
 9515
 9516    def __init__(
 9517        self,
 9518        meta=None,
 9519        rate_limit=None,
 9520        remote_identity_group=None,
 9521    ):
 9522        self.meta = meta if meta is not None else None
 9523        '''
 9524         Reserved for future use.
 9525        '''
 9526        self.rate_limit = rate_limit if rate_limit is not None else None
 9527        '''
 9528         Rate limit information.
 9529        '''
 9530        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
 9531        '''
 9532         The requested RemoteIdentityGroup.
 9533        '''
 9534
 9535    def __repr__(self):
 9536        return '<sdm.RemoteIdentityGroupGetResponse ' + \
 9537            'meta: ' + repr(self.meta) + ' ' +\
 9538            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9539            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
 9540            '>'
 9541
 9542    def to_dict(self):
 9543        return {
 9544            'meta': self.meta,
 9545            'rate_limit': self.rate_limit,
 9546            'remote_identity_group': self.remote_identity_group,
 9547        }
 9548
 9549    @classmethod
 9550    def from_dict(cls, d):
 9551        return cls(
 9552            meta=d.get('meta'),
 9553            rate_limit=d.get('rate_limit'),
 9554            remote_identity_group=d.get('remote_identity_group'),
 9555        )
 9556
 9557
 9558class RemoteIdentityUpdateResponse:
 9559    '''
 9560         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
 9561     a RemoteIdentityUpdateRequest.
 9562    '''
 9563    __slots__ = [
 9564        'meta',
 9565        'rate_limit',
 9566        'remote_identity',
 9567    ]
 9568
 9569    def __init__(
 9570        self,
 9571        meta=None,
 9572        rate_limit=None,
 9573        remote_identity=None,
 9574    ):
 9575        self.meta = meta if meta is not None else None
 9576        '''
 9577         Reserved for future use.
 9578        '''
 9579        self.rate_limit = rate_limit if rate_limit is not None else None
 9580        '''
 9581         Rate limit information.
 9582        '''
 9583        self.remote_identity = remote_identity if remote_identity is not None else None
 9584        '''
 9585         The updated RemoteIdentity.
 9586        '''
 9587
 9588    def __repr__(self):
 9589        return '<sdm.RemoteIdentityUpdateResponse ' + \
 9590            'meta: ' + repr(self.meta) + ' ' +\
 9591            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9592            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9593            '>'
 9594
 9595    def to_dict(self):
 9596        return {
 9597            'meta': self.meta,
 9598            'rate_limit': self.rate_limit,
 9599            'remote_identity': self.remote_identity,
 9600        }
 9601
 9602    @classmethod
 9603    def from_dict(cls, d):
 9604        return cls(
 9605            meta=d.get('meta'),
 9606            rate_limit=d.get('rate_limit'),
 9607            remote_identity=d.get('remote_identity'),
 9608        )
 9609
 9610
 9611class ResourceCreateResponse:
 9612    '''
 9613         ResourceCreateResponse reports how the Resources were created in the system.
 9614    '''
 9615    __slots__ = [
 9616        'meta',
 9617        'rate_limit',
 9618        'resource',
 9619    ]
 9620
 9621    def __init__(
 9622        self,
 9623        meta=None,
 9624        rate_limit=None,
 9625        resource=None,
 9626    ):
 9627        self.meta = meta if meta is not None else None
 9628        '''
 9629         Reserved for future use.
 9630        '''
 9631        self.rate_limit = rate_limit if rate_limit is not None else None
 9632        '''
 9633         Rate limit information.
 9634        '''
 9635        self.resource = resource if resource is not None else None
 9636        '''
 9637         The created Resource.
 9638        '''
 9639
 9640    def __repr__(self):
 9641        return '<sdm.ResourceCreateResponse ' + \
 9642            'meta: ' + repr(self.meta) + ' ' +\
 9643            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9644            'resource: ' + repr(self.resource) + ' ' +\
 9645            '>'
 9646
 9647    def to_dict(self):
 9648        return {
 9649            'meta': self.meta,
 9650            'rate_limit': self.rate_limit,
 9651            'resource': self.resource,
 9652        }
 9653
 9654    @classmethod
 9655    def from_dict(cls, d):
 9656        return cls(
 9657            meta=d.get('meta'),
 9658            rate_limit=d.get('rate_limit'),
 9659            resource=d.get('resource'),
 9660        )
 9661
 9662
 9663class ResourceDeleteResponse:
 9664    '''
 9665         ResourceDeleteResponse returns information about a Resource that was deleted.
 9666    '''
 9667    __slots__ = [
 9668        'meta',
 9669        'rate_limit',
 9670    ]
 9671
 9672    def __init__(
 9673        self,
 9674        meta=None,
 9675        rate_limit=None,
 9676    ):
 9677        self.meta = meta if meta is not None else None
 9678        '''
 9679         Reserved for future use.
 9680        '''
 9681        self.rate_limit = rate_limit if rate_limit is not None else None
 9682        '''
 9683         Rate limit information.
 9684        '''
 9685
 9686    def __repr__(self):
 9687        return '<sdm.ResourceDeleteResponse ' + \
 9688            'meta: ' + repr(self.meta) + ' ' +\
 9689            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9690            '>'
 9691
 9692    def to_dict(self):
 9693        return {
 9694            'meta': self.meta,
 9695            'rate_limit': self.rate_limit,
 9696        }
 9697
 9698    @classmethod
 9699    def from_dict(cls, d):
 9700        return cls(
 9701            meta=d.get('meta'),
 9702            rate_limit=d.get('rate_limit'),
 9703        )
 9704
 9705
 9706class ResourceGetResponse:
 9707    '''
 9708         ResourceGetResponse returns a requested Resource.
 9709    '''
 9710    __slots__ = [
 9711        'meta',
 9712        'rate_limit',
 9713        'resource',
 9714    ]
 9715
 9716    def __init__(
 9717        self,
 9718        meta=None,
 9719        rate_limit=None,
 9720        resource=None,
 9721    ):
 9722        self.meta = meta if meta is not None else None
 9723        '''
 9724         Reserved for future use.
 9725        '''
 9726        self.rate_limit = rate_limit if rate_limit is not None else None
 9727        '''
 9728         Rate limit information.
 9729        '''
 9730        self.resource = resource if resource is not None else None
 9731        '''
 9732         The requested Resource.
 9733        '''
 9734
 9735    def __repr__(self):
 9736        return '<sdm.ResourceGetResponse ' + \
 9737            'meta: ' + repr(self.meta) + ' ' +\
 9738            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9739            'resource: ' + repr(self.resource) + ' ' +\
 9740            '>'
 9741
 9742    def to_dict(self):
 9743        return {
 9744            'meta': self.meta,
 9745            'rate_limit': self.rate_limit,
 9746            'resource': self.resource,
 9747        }
 9748
 9749    @classmethod
 9750    def from_dict(cls, d):
 9751        return cls(
 9752            meta=d.get('meta'),
 9753            rate_limit=d.get('rate_limit'),
 9754            resource=d.get('resource'),
 9755        )
 9756
 9757
 9758class ResourceUpdateResponse:
 9759    '''
 9760         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
 9761     a ResourceUpdateRequest.
 9762    '''
 9763    __slots__ = [
 9764        'meta',
 9765        'rate_limit',
 9766        'resource',
 9767    ]
 9768
 9769    def __init__(
 9770        self,
 9771        meta=None,
 9772        rate_limit=None,
 9773        resource=None,
 9774    ):
 9775        self.meta = meta if meta is not None else None
 9776        '''
 9777         Reserved for future use.
 9778        '''
 9779        self.rate_limit = rate_limit if rate_limit is not None else None
 9780        '''
 9781         Rate limit information.
 9782        '''
 9783        self.resource = resource if resource is not None else None
 9784        '''
 9785         The updated Resource.
 9786        '''
 9787
 9788    def __repr__(self):
 9789        return '<sdm.ResourceUpdateResponse ' + \
 9790            'meta: ' + repr(self.meta) + ' ' +\
 9791            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9792            'resource: ' + repr(self.resource) + ' ' +\
 9793            '>'
 9794
 9795    def to_dict(self):
 9796        return {
 9797            'meta': self.meta,
 9798            'rate_limit': self.rate_limit,
 9799            'resource': self.resource,
 9800        }
 9801
 9802    @classmethod
 9803    def from_dict(cls, d):
 9804        return cls(
 9805            meta=d.get('meta'),
 9806            rate_limit=d.get('rate_limit'),
 9807            resource=d.get('resource'),
 9808        )
 9809
 9810
 9811class Role:
 9812    '''
 9813         A Role has a list of access rules which determine which Resources the members
 9814     of the Role have access to. An Account can be a member of multiple Roles via
 9815     AccountAttachments.
 9816    '''
 9817    __slots__ = [
 9818        'access_rules',
 9819        'id',
 9820        'name',
 9821        'tags',
 9822    ]
 9823
 9824    def __init__(
 9825        self,
 9826        access_rules=None,
 9827        id=None,
 9828        name=None,
 9829        tags=None,
 9830    ):
 9831        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
 9832        )
 9833        '''
 9834         AccessRules is a list of access rules defining the resources this Role has access to.
 9835        '''
 9836        self.id = id if id is not None else ''
 9837        '''
 9838         Unique identifier of the Role.
 9839        '''
 9840        self.name = name if name is not None else ''
 9841        '''
 9842         Unique human-readable name of the Role.
 9843        '''
 9844        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9845        '''
 9846         Tags is a map of key, value pairs.
 9847        '''
 9848
 9849    def __repr__(self):
 9850        return '<sdm.Role ' + \
 9851            'access_rules: ' + repr(self.access_rules) + ' ' +\
 9852            'id: ' + repr(self.id) + ' ' +\
 9853            'name: ' + repr(self.name) + ' ' +\
 9854            'tags: ' + repr(self.tags) + ' ' +\
 9855            '>'
 9856
 9857    def to_dict(self):
 9858        return {
 9859            'access_rules': self.access_rules,
 9860            'id': self.id,
 9861            'name': self.name,
 9862            'tags': self.tags,
 9863        }
 9864
 9865    @classmethod
 9866    def from_dict(cls, d):
 9867        return cls(
 9868            access_rules=d.get('access_rules'),
 9869            id=d.get('id'),
 9870            name=d.get('name'),
 9871            tags=d.get('tags'),
 9872        )
 9873
 9874
 9875class RoleCreateResponse:
 9876    '''
 9877         RoleCreateResponse reports how the Roles were created in the system. It can
 9878     communicate partial successes or failures.
 9879    '''
 9880    __slots__ = [
 9881        'meta',
 9882        'rate_limit',
 9883        'role',
 9884    ]
 9885
 9886    def __init__(
 9887        self,
 9888        meta=None,
 9889        rate_limit=None,
 9890        role=None,
 9891    ):
 9892        self.meta = meta if meta is not None else None
 9893        '''
 9894         Reserved for future use.
 9895        '''
 9896        self.rate_limit = rate_limit if rate_limit is not None else None
 9897        '''
 9898         Rate limit information.
 9899        '''
 9900        self.role = role if role is not None else None
 9901        '''
 9902         The created Role.
 9903        '''
 9904
 9905    def __repr__(self):
 9906        return '<sdm.RoleCreateResponse ' + \
 9907            'meta: ' + repr(self.meta) + ' ' +\
 9908            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9909            'role: ' + repr(self.role) + ' ' +\
 9910            '>'
 9911
 9912    def to_dict(self):
 9913        return {
 9914            'meta': self.meta,
 9915            'rate_limit': self.rate_limit,
 9916            'role': self.role,
 9917        }
 9918
 9919    @classmethod
 9920    def from_dict(cls, d):
 9921        return cls(
 9922            meta=d.get('meta'),
 9923            rate_limit=d.get('rate_limit'),
 9924            role=d.get('role'),
 9925        )
 9926
 9927
 9928class RoleDeleteResponse:
 9929    '''
 9930         RoleDeleteResponse returns information about a Role that was deleted.
 9931    '''
 9932    __slots__ = [
 9933        'meta',
 9934        'rate_limit',
 9935    ]
 9936
 9937    def __init__(
 9938        self,
 9939        meta=None,
 9940        rate_limit=None,
 9941    ):
 9942        self.meta = meta if meta is not None else None
 9943        '''
 9944         Reserved for future use.
 9945        '''
 9946        self.rate_limit = rate_limit if rate_limit is not None else None
 9947        '''
 9948         Rate limit information.
 9949        '''
 9950
 9951    def __repr__(self):
 9952        return '<sdm.RoleDeleteResponse ' + \
 9953            'meta: ' + repr(self.meta) + ' ' +\
 9954            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9955            '>'
 9956
 9957    def to_dict(self):
 9958        return {
 9959            'meta': self.meta,
 9960            'rate_limit': self.rate_limit,
 9961        }
 9962
 9963    @classmethod
 9964    def from_dict(cls, d):
 9965        return cls(
 9966            meta=d.get('meta'),
 9967            rate_limit=d.get('rate_limit'),
 9968        )
 9969
 9970
 9971class RoleGetResponse:
 9972    '''
 9973         RoleGetResponse returns a requested Role.
 9974    '''
 9975    __slots__ = [
 9976        'meta',
 9977        'rate_limit',
 9978        'role',
 9979    ]
 9980
 9981    def __init__(
 9982        self,
 9983        meta=None,
 9984        rate_limit=None,
 9985        role=None,
 9986    ):
 9987        self.meta = meta if meta is not None else None
 9988        '''
 9989         Reserved for future use.
 9990        '''
 9991        self.rate_limit = rate_limit if rate_limit is not None else None
 9992        '''
 9993         Rate limit information.
 9994        '''
 9995        self.role = role if role is not None else None
 9996        '''
 9997         The requested Role.
 9998        '''
 9999
10000    def __repr__(self):
10001        return '<sdm.RoleGetResponse ' + \
10002            'meta: ' + repr(self.meta) + ' ' +\
10003            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10004            'role: ' + repr(self.role) + ' ' +\
10005            '>'
10006
10007    def to_dict(self):
10008        return {
10009            'meta': self.meta,
10010            'rate_limit': self.rate_limit,
10011            'role': self.role,
10012        }
10013
10014    @classmethod
10015    def from_dict(cls, d):
10016        return cls(
10017            meta=d.get('meta'),
10018            rate_limit=d.get('rate_limit'),
10019            role=d.get('role'),
10020        )
10021
10022
10023class RoleUpdateResponse:
10024    '''
10025         RoleUpdateResponse returns the fields of a Role after it has been updated by
10026     a RoleUpdateRequest.
10027    '''
10028    __slots__ = [
10029        'meta',
10030        'rate_limit',
10031        'role',
10032    ]
10033
10034    def __init__(
10035        self,
10036        meta=None,
10037        rate_limit=None,
10038        role=None,
10039    ):
10040        self.meta = meta if meta is not None else None
10041        '''
10042         Reserved for future use.
10043        '''
10044        self.rate_limit = rate_limit if rate_limit is not None else None
10045        '''
10046         Rate limit information.
10047        '''
10048        self.role = role if role is not None else None
10049        '''
10050         The updated Role.
10051        '''
10052
10053    def __repr__(self):
10054        return '<sdm.RoleUpdateResponse ' + \
10055            'meta: ' + repr(self.meta) + ' ' +\
10056            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10057            'role: ' + repr(self.role) + ' ' +\
10058            '>'
10059
10060    def to_dict(self):
10061        return {
10062            'meta': self.meta,
10063            'rate_limit': self.rate_limit,
10064            'role': self.role,
10065        }
10066
10067    @classmethod
10068    def from_dict(cls, d):
10069        return cls(
10070            meta=d.get('meta'),
10071            rate_limit=d.get('rate_limit'),
10072            role=d.get('role'),
10073        )
10074
10075
10076class SQLServer:
10077    __slots__ = [
10078        'bind_interface',
10079        'database',
10080        'egress_filter',
10081        'healthy',
10082        'hostname',
10083        'id',
10084        'name',
10085        'override_database',
10086        'password',
10087        'port',
10088        'port_override',
10089        'schema',
10090        'secret_store_id',
10091        'tags',
10092        'username',
10093    ]
10094
10095    def __init__(
10096        self,
10097        bind_interface=None,
10098        database=None,
10099        egress_filter=None,
10100        healthy=None,
10101        hostname=None,
10102        id=None,
10103        name=None,
10104        override_database=None,
10105        password=None,
10106        port=None,
10107        port_override=None,
10108        schema=None,
10109        secret_store_id=None,
10110        tags=None,
10111        username=None,
10112    ):
10113        self.bind_interface = bind_interface if bind_interface is not None else ''
10114        '''
10115         Bind interface
10116        '''
10117        self.database = database if database is not None else ''
10118        self.egress_filter = egress_filter if egress_filter is not None else ''
10119        '''
10120         A filter applied to the routing logic to pin datasource to nodes.
10121        '''
10122        self.healthy = healthy if healthy is not None else False
10123        '''
10124         True if the datasource is reachable and the credentials are valid.
10125        '''
10126        self.hostname = hostname if hostname is not None else ''
10127        self.id = id if id is not None else ''
10128        '''
10129         Unique identifier of the Resource.
10130        '''
10131        self.name = name if name is not None else ''
10132        '''
10133         Unique human-readable name of the Resource.
10134        '''
10135        self.override_database = override_database if override_database is not None else False
10136        self.password = password if password is not None else ''
10137        self.port = port if port is not None else 0
10138        self.port_override = port_override if port_override is not None else 0
10139        self.schema = schema if schema is not None else ''
10140        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10141        '''
10142         ID of the secret store containing credentials for this resource, if any.
10143        '''
10144        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10145        '''
10146         Tags is a map of key, value pairs.
10147        '''
10148        self.username = username if username is not None else ''
10149
10150    def __repr__(self):
10151        return '<sdm.SQLServer ' + \
10152            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10153            'database: ' + repr(self.database) + ' ' +\
10154            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10155            'healthy: ' + repr(self.healthy) + ' ' +\
10156            'hostname: ' + repr(self.hostname) + ' ' +\
10157            'id: ' + repr(self.id) + ' ' +\
10158            'name: ' + repr(self.name) + ' ' +\
10159            'override_database: ' + repr(self.override_database) + ' ' +\
10160            'password: ' + repr(self.password) + ' ' +\
10161            'port: ' + repr(self.port) + ' ' +\
10162            'port_override: ' + repr(self.port_override) + ' ' +\
10163            'schema: ' + repr(self.schema) + ' ' +\
10164            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10165            'tags: ' + repr(self.tags) + ' ' +\
10166            'username: ' + repr(self.username) + ' ' +\
10167            '>'
10168
10169    def to_dict(self):
10170        return {
10171            'bind_interface': self.bind_interface,
10172            'database': self.database,
10173            'egress_filter': self.egress_filter,
10174            'healthy': self.healthy,
10175            'hostname': self.hostname,
10176            'id': self.id,
10177            'name': self.name,
10178            'override_database': self.override_database,
10179            'password': self.password,
10180            'port': self.port,
10181            'port_override': self.port_override,
10182            'schema': self.schema,
10183            'secret_store_id': self.secret_store_id,
10184            'tags': self.tags,
10185            'username': self.username,
10186        }
10187
10188    @classmethod
10189    def from_dict(cls, d):
10190        return cls(
10191            bind_interface=d.get('bind_interface'),
10192            database=d.get('database'),
10193            egress_filter=d.get('egress_filter'),
10194            healthy=d.get('healthy'),
10195            hostname=d.get('hostname'),
10196            id=d.get('id'),
10197            name=d.get('name'),
10198            override_database=d.get('override_database'),
10199            password=d.get('password'),
10200            port=d.get('port'),
10201            port_override=d.get('port_override'),
10202            schema=d.get('schema'),
10203            secret_store_id=d.get('secret_store_id'),
10204            tags=d.get('tags'),
10205            username=d.get('username'),
10206        )
10207
10208
10209class SSH:
10210    __slots__ = [
10211        'allow_deprecated_key_exchanges',
10212        'bind_interface',
10213        'egress_filter',
10214        'healthy',
10215        'hostname',
10216        'id',
10217        'key_type',
10218        'name',
10219        'port',
10220        'port_forwarding',
10221        'port_override',
10222        'public_key',
10223        'secret_store_id',
10224        'tags',
10225        'username',
10226    ]
10227
10228    def __init__(
10229        self,
10230        allow_deprecated_key_exchanges=None,
10231        bind_interface=None,
10232        egress_filter=None,
10233        healthy=None,
10234        hostname=None,
10235        id=None,
10236        key_type=None,
10237        name=None,
10238        port=None,
10239        port_forwarding=None,
10240        port_override=None,
10241        public_key=None,
10242        secret_store_id=None,
10243        tags=None,
10244        username=None,
10245    ):
10246        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10247        self.bind_interface = bind_interface if bind_interface is not None else ''
10248        '''
10249         Bind interface
10250        '''
10251        self.egress_filter = egress_filter if egress_filter is not None else ''
10252        '''
10253         A filter applied to the routing logic to pin datasource to nodes.
10254        '''
10255        self.healthy = healthy if healthy is not None else False
10256        '''
10257         True if the datasource is reachable and the credentials are valid.
10258        '''
10259        self.hostname = hostname if hostname is not None else ''
10260        self.id = id if id is not None else ''
10261        '''
10262         Unique identifier of the Resource.
10263        '''
10264        self.key_type = key_type if key_type is not None else ''
10265        self.name = name if name is not None else ''
10266        '''
10267         Unique human-readable name of the Resource.
10268        '''
10269        self.port = port if port is not None else 0
10270        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10271        self.port_override = port_override if port_override is not None else 0
10272        self.public_key = public_key if public_key is not None else ''
10273        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10274        '''
10275         ID of the secret store containing credentials for this resource, if any.
10276        '''
10277        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10278        '''
10279         Tags is a map of key, value pairs.
10280        '''
10281        self.username = username if username is not None else ''
10282
10283    def __repr__(self):
10284        return '<sdm.SSH ' + \
10285            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10286            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10287            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10288            'healthy: ' + repr(self.healthy) + ' ' +\
10289            'hostname: ' + repr(self.hostname) + ' ' +\
10290            'id: ' + repr(self.id) + ' ' +\
10291            'key_type: ' + repr(self.key_type) + ' ' +\
10292            'name: ' + repr(self.name) + ' ' +\
10293            'port: ' + repr(self.port) + ' ' +\
10294            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10295            'port_override: ' + repr(self.port_override) + ' ' +\
10296            'public_key: ' + repr(self.public_key) + ' ' +\
10297            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10298            'tags: ' + repr(self.tags) + ' ' +\
10299            'username: ' + repr(self.username) + ' ' +\
10300            '>'
10301
10302    def to_dict(self):
10303        return {
10304            'allow_deprecated_key_exchanges':
10305            self.allow_deprecated_key_exchanges,
10306            'bind_interface': self.bind_interface,
10307            'egress_filter': self.egress_filter,
10308            'healthy': self.healthy,
10309            'hostname': self.hostname,
10310            'id': self.id,
10311            'key_type': self.key_type,
10312            'name': self.name,
10313            'port': self.port,
10314            'port_forwarding': self.port_forwarding,
10315            'port_override': self.port_override,
10316            'public_key': self.public_key,
10317            'secret_store_id': self.secret_store_id,
10318            'tags': self.tags,
10319            'username': self.username,
10320        }
10321
10322    @classmethod
10323    def from_dict(cls, d):
10324        return cls(
10325            allow_deprecated_key_exchanges=d.get(
10326                'allow_deprecated_key_exchanges'),
10327            bind_interface=d.get('bind_interface'),
10328            egress_filter=d.get('egress_filter'),
10329            healthy=d.get('healthy'),
10330            hostname=d.get('hostname'),
10331            id=d.get('id'),
10332            key_type=d.get('key_type'),
10333            name=d.get('name'),
10334            port=d.get('port'),
10335            port_forwarding=d.get('port_forwarding'),
10336            port_override=d.get('port_override'),
10337            public_key=d.get('public_key'),
10338            secret_store_id=d.get('secret_store_id'),
10339            tags=d.get('tags'),
10340            username=d.get('username'),
10341        )
10342
10343
10344class SSHCert:
10345    __slots__ = [
10346        'allow_deprecated_key_exchanges',
10347        'bind_interface',
10348        'egress_filter',
10349        'healthy',
10350        'hostname',
10351        'id',
10352        'key_type',
10353        'name',
10354        'port',
10355        'port_forwarding',
10356        'port_override',
10357        'remote_identity_group_id',
10358        'remote_identity_healthcheck_username',
10359        'secret_store_id',
10360        'tags',
10361        'username',
10362    ]
10363
10364    def __init__(
10365        self,
10366        allow_deprecated_key_exchanges=None,
10367        bind_interface=None,
10368        egress_filter=None,
10369        healthy=None,
10370        hostname=None,
10371        id=None,
10372        key_type=None,
10373        name=None,
10374        port=None,
10375        port_forwarding=None,
10376        port_override=None,
10377        remote_identity_group_id=None,
10378        remote_identity_healthcheck_username=None,
10379        secret_store_id=None,
10380        tags=None,
10381        username=None,
10382    ):
10383        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10384        self.bind_interface = bind_interface if bind_interface is not None else ''
10385        '''
10386         Bind interface
10387        '''
10388        self.egress_filter = egress_filter if egress_filter is not None else ''
10389        '''
10390         A filter applied to the routing logic to pin datasource to nodes.
10391        '''
10392        self.healthy = healthy if healthy is not None else False
10393        '''
10394         True if the datasource is reachable and the credentials are valid.
10395        '''
10396        self.hostname = hostname if hostname is not None else ''
10397        self.id = id if id is not None else ''
10398        '''
10399         Unique identifier of the Resource.
10400        '''
10401        self.key_type = key_type if key_type is not None else ''
10402        self.name = name if name is not None else ''
10403        '''
10404         Unique human-readable name of the Resource.
10405        '''
10406        self.port = port if port is not None else 0
10407        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10408        self.port_override = port_override if port_override is not None else 0
10409        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10410        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10411        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10412        '''
10413         ID of the secret store containing credentials for this resource, if any.
10414        '''
10415        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10416        '''
10417         Tags is a map of key, value pairs.
10418        '''
10419        self.username = username if username is not None else ''
10420
10421    def __repr__(self):
10422        return '<sdm.SSHCert ' + \
10423            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10424            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10425            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10426            'healthy: ' + repr(self.healthy) + ' ' +\
10427            'hostname: ' + repr(self.hostname) + ' ' +\
10428            'id: ' + repr(self.id) + ' ' +\
10429            'key_type: ' + repr(self.key_type) + ' ' +\
10430            'name: ' + repr(self.name) + ' ' +\
10431            'port: ' + repr(self.port) + ' ' +\
10432            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10433            'port_override: ' + repr(self.port_override) + ' ' +\
10434            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10435            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
10436            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10437            'tags: ' + repr(self.tags) + ' ' +\
10438            'username: ' + repr(self.username) + ' ' +\
10439            '>'
10440
10441    def to_dict(self):
10442        return {
10443            'allow_deprecated_key_exchanges':
10444            self.allow_deprecated_key_exchanges,
10445            'bind_interface': self.bind_interface,
10446            'egress_filter': self.egress_filter,
10447            'healthy': self.healthy,
10448            'hostname': self.hostname,
10449            'id': self.id,
10450            'key_type': self.key_type,
10451            'name': self.name,
10452            'port': self.port,
10453            'port_forwarding': self.port_forwarding,
10454            'port_override': self.port_override,
10455            'remote_identity_group_id': self.remote_identity_group_id,
10456            'remote_identity_healthcheck_username':
10457            self.remote_identity_healthcheck_username,
10458            'secret_store_id': self.secret_store_id,
10459            'tags': self.tags,
10460            'username': self.username,
10461        }
10462
10463    @classmethod
10464    def from_dict(cls, d):
10465        return cls(
10466            allow_deprecated_key_exchanges=d.get(
10467                'allow_deprecated_key_exchanges'),
10468            bind_interface=d.get('bind_interface'),
10469            egress_filter=d.get('egress_filter'),
10470            healthy=d.get('healthy'),
10471            hostname=d.get('hostname'),
10472            id=d.get('id'),
10473            key_type=d.get('key_type'),
10474            name=d.get('name'),
10475            port=d.get('port'),
10476            port_forwarding=d.get('port_forwarding'),
10477            port_override=d.get('port_override'),
10478            remote_identity_group_id=d.get('remote_identity_group_id'),
10479            remote_identity_healthcheck_username=d.get(
10480                'remote_identity_healthcheck_username'),
10481            secret_store_id=d.get('secret_store_id'),
10482            tags=d.get('tags'),
10483            username=d.get('username'),
10484        )
10485
10486
10487class SSHCustomerKey:
10488    __slots__ = [
10489        'allow_deprecated_key_exchanges',
10490        'bind_interface',
10491        'egress_filter',
10492        'healthy',
10493        'hostname',
10494        'id',
10495        'name',
10496        'port',
10497        'port_forwarding',
10498        'port_override',
10499        'private_key',
10500        'secret_store_id',
10501        'tags',
10502        'username',
10503    ]
10504
10505    def __init__(
10506        self,
10507        allow_deprecated_key_exchanges=None,
10508        bind_interface=None,
10509        egress_filter=None,
10510        healthy=None,
10511        hostname=None,
10512        id=None,
10513        name=None,
10514        port=None,
10515        port_forwarding=None,
10516        port_override=None,
10517        private_key=None,
10518        secret_store_id=None,
10519        tags=None,
10520        username=None,
10521    ):
10522        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10523        self.bind_interface = bind_interface if bind_interface is not None else ''
10524        '''
10525         Bind interface
10526        '''
10527        self.egress_filter = egress_filter if egress_filter is not None else ''
10528        '''
10529         A filter applied to the routing logic to pin datasource to nodes.
10530        '''
10531        self.healthy = healthy if healthy is not None else False
10532        '''
10533         True if the datasource is reachable and the credentials are valid.
10534        '''
10535        self.hostname = hostname if hostname is not None else ''
10536        self.id = id if id is not None else ''
10537        '''
10538         Unique identifier of the Resource.
10539        '''
10540        self.name = name if name is not None else ''
10541        '''
10542         Unique human-readable name of the Resource.
10543        '''
10544        self.port = port if port is not None else 0
10545        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10546        self.port_override = port_override if port_override is not None else 0
10547        self.private_key = private_key if private_key is not None else ''
10548        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10549        '''
10550         ID of the secret store containing credentials for this resource, if any.
10551        '''
10552        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10553        '''
10554         Tags is a map of key, value pairs.
10555        '''
10556        self.username = username if username is not None else ''
10557
10558    def __repr__(self):
10559        return '<sdm.SSHCustomerKey ' + \
10560            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10561            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10562            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10563            'healthy: ' + repr(self.healthy) + ' ' +\
10564            'hostname: ' + repr(self.hostname) + ' ' +\
10565            'id: ' + repr(self.id) + ' ' +\
10566            'name: ' + repr(self.name) + ' ' +\
10567            'port: ' + repr(self.port) + ' ' +\
10568            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10569            'port_override: ' + repr(self.port_override) + ' ' +\
10570            'private_key: ' + repr(self.private_key) + ' ' +\
10571            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10572            'tags: ' + repr(self.tags) + ' ' +\
10573            'username: ' + repr(self.username) + ' ' +\
10574            '>'
10575
10576    def to_dict(self):
10577        return {
10578            'allow_deprecated_key_exchanges':
10579            self.allow_deprecated_key_exchanges,
10580            'bind_interface': self.bind_interface,
10581            'egress_filter': self.egress_filter,
10582            'healthy': self.healthy,
10583            'hostname': self.hostname,
10584            'id': self.id,
10585            'name': self.name,
10586            'port': self.port,
10587            'port_forwarding': self.port_forwarding,
10588            'port_override': self.port_override,
10589            'private_key': self.private_key,
10590            'secret_store_id': self.secret_store_id,
10591            'tags': self.tags,
10592            'username': self.username,
10593        }
10594
10595    @classmethod
10596    def from_dict(cls, d):
10597        return cls(
10598            allow_deprecated_key_exchanges=d.get(
10599                'allow_deprecated_key_exchanges'),
10600            bind_interface=d.get('bind_interface'),
10601            egress_filter=d.get('egress_filter'),
10602            healthy=d.get('healthy'),
10603            hostname=d.get('hostname'),
10604            id=d.get('id'),
10605            name=d.get('name'),
10606            port=d.get('port'),
10607            port_forwarding=d.get('port_forwarding'),
10608            port_override=d.get('port_override'),
10609            private_key=d.get('private_key'),
10610            secret_store_id=d.get('secret_store_id'),
10611            tags=d.get('tags'),
10612            username=d.get('username'),
10613        )
10614
10615
10616class SecretStoreCreateResponse:
10617    '''
10618         SecretStoreCreateResponse reports how the SecretStores were created in the system.
10619    '''
10620    __slots__ = [
10621        'meta',
10622        'rate_limit',
10623        'secret_store',
10624    ]
10625
10626    def __init__(
10627        self,
10628        meta=None,
10629        rate_limit=None,
10630        secret_store=None,
10631    ):
10632        self.meta = meta if meta is not None else None
10633        '''
10634         Reserved for future use.
10635        '''
10636        self.rate_limit = rate_limit if rate_limit is not None else None
10637        '''
10638         Rate limit information.
10639        '''
10640        self.secret_store = secret_store if secret_store is not None else None
10641        '''
10642         The created SecretStore.
10643        '''
10644
10645    def __repr__(self):
10646        return '<sdm.SecretStoreCreateResponse ' + \
10647            'meta: ' + repr(self.meta) + ' ' +\
10648            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10649            'secret_store: ' + repr(self.secret_store) + ' ' +\
10650            '>'
10651
10652    def to_dict(self):
10653        return {
10654            'meta': self.meta,
10655            'rate_limit': self.rate_limit,
10656            'secret_store': self.secret_store,
10657        }
10658
10659    @classmethod
10660    def from_dict(cls, d):
10661        return cls(
10662            meta=d.get('meta'),
10663            rate_limit=d.get('rate_limit'),
10664            secret_store=d.get('secret_store'),
10665        )
10666
10667
10668class SecretStoreDeleteResponse:
10669    '''
10670         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
10671    '''
10672    __slots__ = [
10673        'meta',
10674        'rate_limit',
10675    ]
10676
10677    def __init__(
10678        self,
10679        meta=None,
10680        rate_limit=None,
10681    ):
10682        self.meta = meta if meta is not None else None
10683        '''
10684         Reserved for future use.
10685        '''
10686        self.rate_limit = rate_limit if rate_limit is not None else None
10687        '''
10688         Rate limit information.
10689        '''
10690
10691    def __repr__(self):
10692        return '<sdm.SecretStoreDeleteResponse ' + \
10693            'meta: ' + repr(self.meta) + ' ' +\
10694            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10695            '>'
10696
10697    def to_dict(self):
10698        return {
10699            'meta': self.meta,
10700            'rate_limit': self.rate_limit,
10701        }
10702
10703    @classmethod
10704    def from_dict(cls, d):
10705        return cls(
10706            meta=d.get('meta'),
10707            rate_limit=d.get('rate_limit'),
10708        )
10709
10710
10711class SecretStoreGetResponse:
10712    '''
10713         SecretStoreGetResponse returns a requested SecretStore.
10714    '''
10715    __slots__ = [
10716        'meta',
10717        'rate_limit',
10718        'secret_store',
10719    ]
10720
10721    def __init__(
10722        self,
10723        meta=None,
10724        rate_limit=None,
10725        secret_store=None,
10726    ):
10727        self.meta = meta if meta is not None else None
10728        '''
10729         Reserved for future use.
10730        '''
10731        self.rate_limit = rate_limit if rate_limit is not None else None
10732        '''
10733         Rate limit information.
10734        '''
10735        self.secret_store = secret_store if secret_store is not None else None
10736        '''
10737         The requested SecretStore.
10738        '''
10739
10740    def __repr__(self):
10741        return '<sdm.SecretStoreGetResponse ' + \
10742            'meta: ' + repr(self.meta) + ' ' +\
10743            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10744            'secret_store: ' + repr(self.secret_store) + ' ' +\
10745            '>'
10746
10747    def to_dict(self):
10748        return {
10749            'meta': self.meta,
10750            'rate_limit': self.rate_limit,
10751            'secret_store': self.secret_store,
10752        }
10753
10754    @classmethod
10755    def from_dict(cls, d):
10756        return cls(
10757            meta=d.get('meta'),
10758            rate_limit=d.get('rate_limit'),
10759            secret_store=d.get('secret_store'),
10760        )
10761
10762
10763class SecretStoreUpdateResponse:
10764    '''
10765         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
10766     a SecretStoreUpdateRequest.
10767    '''
10768    __slots__ = [
10769        'meta',
10770        'rate_limit',
10771        'secret_store',
10772    ]
10773
10774    def __init__(
10775        self,
10776        meta=None,
10777        rate_limit=None,
10778        secret_store=None,
10779    ):
10780        self.meta = meta if meta is not None else None
10781        '''
10782         Reserved for future use.
10783        '''
10784        self.rate_limit = rate_limit if rate_limit is not None else None
10785        '''
10786         Rate limit information.
10787        '''
10788        self.secret_store = secret_store if secret_store is not None else None
10789        '''
10790         The updated SecretStore.
10791        '''
10792
10793    def __repr__(self):
10794        return '<sdm.SecretStoreUpdateResponse ' + \
10795            'meta: ' + repr(self.meta) + ' ' +\
10796            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10797            'secret_store: ' + repr(self.secret_store) + ' ' +\
10798            '>'
10799
10800    def to_dict(self):
10801        return {
10802            'meta': self.meta,
10803            'rate_limit': self.rate_limit,
10804            'secret_store': self.secret_store,
10805        }
10806
10807    @classmethod
10808    def from_dict(cls, d):
10809        return cls(
10810            meta=d.get('meta'),
10811            rate_limit=d.get('rate_limit'),
10812            secret_store=d.get('secret_store'),
10813        )
10814
10815
10816class Service:
10817    '''
10818         A Service is a service account that can connect to resources they are granted
10819     directly, or granted via roles. Services are typically automated jobs.
10820    '''
10821    __slots__ = [
10822        'id',
10823        'name',
10824        'suspended',
10825        'tags',
10826    ]
10827
10828    def __init__(
10829        self,
10830        id=None,
10831        name=None,
10832        suspended=None,
10833        tags=None,
10834    ):
10835        self.id = id if id is not None else ''
10836        '''
10837         Unique identifier of the Service.
10838        '''
10839        self.name = name if name is not None else ''
10840        '''
10841         Unique human-readable name of the Service.
10842        '''
10843        self.suspended = suspended if suspended is not None else False
10844        '''
10845         The Service's suspended state.
10846        '''
10847        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10848        '''
10849         Tags is a map of key, value pairs.
10850        '''
10851
10852    def __repr__(self):
10853        return '<sdm.Service ' + \
10854            'id: ' + repr(self.id) + ' ' +\
10855            'name: ' + repr(self.name) + ' ' +\
10856            'suspended: ' + repr(self.suspended) + ' ' +\
10857            'tags: ' + repr(self.tags) + ' ' +\
10858            '>'
10859
10860    def to_dict(self):
10861        return {
10862            'id': self.id,
10863            'name': self.name,
10864            'suspended': self.suspended,
10865            'tags': self.tags,
10866        }
10867
10868    @classmethod
10869    def from_dict(cls, d):
10870        return cls(
10871            id=d.get('id'),
10872            name=d.get('name'),
10873            suspended=d.get('suspended'),
10874            tags=d.get('tags'),
10875        )
10876
10877
10878class SingleStore:
10879    __slots__ = [
10880        'bind_interface',
10881        'database',
10882        'egress_filter',
10883        'healthy',
10884        'hostname',
10885        'id',
10886        'name',
10887        'password',
10888        'port',
10889        'port_override',
10890        'secret_store_id',
10891        'tags',
10892        'username',
10893    ]
10894
10895    def __init__(
10896        self,
10897        bind_interface=None,
10898        database=None,
10899        egress_filter=None,
10900        healthy=None,
10901        hostname=None,
10902        id=None,
10903        name=None,
10904        password=None,
10905        port=None,
10906        port_override=None,
10907        secret_store_id=None,
10908        tags=None,
10909        username=None,
10910    ):
10911        self.bind_interface = bind_interface if bind_interface is not None else ''
10912        '''
10913         Bind interface
10914        '''
10915        self.database = database if database is not None else ''
10916        self.egress_filter = egress_filter if egress_filter is not None else ''
10917        '''
10918         A filter applied to the routing logic to pin datasource to nodes.
10919        '''
10920        self.healthy = healthy if healthy is not None else False
10921        '''
10922         True if the datasource is reachable and the credentials are valid.
10923        '''
10924        self.hostname = hostname if hostname is not None else ''
10925        self.id = id if id is not None else ''
10926        '''
10927         Unique identifier of the Resource.
10928        '''
10929        self.name = name if name is not None else ''
10930        '''
10931         Unique human-readable name of the Resource.
10932        '''
10933        self.password = password if password is not None else ''
10934        self.port = port if port is not None else 0
10935        self.port_override = port_override if port_override is not None else 0
10936        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10937        '''
10938         ID of the secret store containing credentials for this resource, if any.
10939        '''
10940        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10941        '''
10942         Tags is a map of key, value pairs.
10943        '''
10944        self.username = username if username is not None else ''
10945
10946    def __repr__(self):
10947        return '<sdm.SingleStore ' + \
10948            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10949            'database: ' + repr(self.database) + ' ' +\
10950            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10951            'healthy: ' + repr(self.healthy) + ' ' +\
10952            'hostname: ' + repr(self.hostname) + ' ' +\
10953            'id: ' + repr(self.id) + ' ' +\
10954            'name: ' + repr(self.name) + ' ' +\
10955            'password: ' + repr(self.password) + ' ' +\
10956            'port: ' + repr(self.port) + ' ' +\
10957            'port_override: ' + repr(self.port_override) + ' ' +\
10958            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10959            'tags: ' + repr(self.tags) + ' ' +\
10960            'username: ' + repr(self.username) + ' ' +\
10961            '>'
10962
10963    def to_dict(self):
10964        return {
10965            'bind_interface': self.bind_interface,
10966            'database': self.database,
10967            'egress_filter': self.egress_filter,
10968            'healthy': self.healthy,
10969            'hostname': self.hostname,
10970            'id': self.id,
10971            'name': self.name,
10972            'password': self.password,
10973            'port': self.port,
10974            'port_override': self.port_override,
10975            'secret_store_id': self.secret_store_id,
10976            'tags': self.tags,
10977            'username': self.username,
10978        }
10979
10980    @classmethod
10981    def from_dict(cls, d):
10982        return cls(
10983            bind_interface=d.get('bind_interface'),
10984            database=d.get('database'),
10985            egress_filter=d.get('egress_filter'),
10986            healthy=d.get('healthy'),
10987            hostname=d.get('hostname'),
10988            id=d.get('id'),
10989            name=d.get('name'),
10990            password=d.get('password'),
10991            port=d.get('port'),
10992            port_override=d.get('port_override'),
10993            secret_store_id=d.get('secret_store_id'),
10994            tags=d.get('tags'),
10995            username=d.get('username'),
10996        )
10997
10998
10999class Snowflake:
11000    __slots__ = [
11001        'bind_interface',
11002        'database',
11003        'egress_filter',
11004        'healthy',
11005        'hostname',
11006        'id',
11007        'name',
11008        'password',
11009        'port_override',
11010        'schema',
11011        'secret_store_id',
11012        'tags',
11013        'username',
11014    ]
11015
11016    def __init__(
11017        self,
11018        bind_interface=None,
11019        database=None,
11020        egress_filter=None,
11021        healthy=None,
11022        hostname=None,
11023        id=None,
11024        name=None,
11025        password=None,
11026        port_override=None,
11027        schema=None,
11028        secret_store_id=None,
11029        tags=None,
11030        username=None,
11031    ):
11032        self.bind_interface = bind_interface if bind_interface is not None else ''
11033        '''
11034         Bind interface
11035        '''
11036        self.database = database if database is not None else ''
11037        self.egress_filter = egress_filter if egress_filter is not None else ''
11038        '''
11039         A filter applied to the routing logic to pin datasource to nodes.
11040        '''
11041        self.healthy = healthy if healthy is not None else False
11042        '''
11043         True if the datasource is reachable and the credentials are valid.
11044        '''
11045        self.hostname = hostname if hostname is not None else ''
11046        self.id = id if id is not None else ''
11047        '''
11048         Unique identifier of the Resource.
11049        '''
11050        self.name = name if name is not None else ''
11051        '''
11052         Unique human-readable name of the Resource.
11053        '''
11054        self.password = password if password is not None else ''
11055        self.port_override = port_override if port_override is not None else 0
11056        self.schema = schema if schema is not None else ''
11057        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11058        '''
11059         ID of the secret store containing credentials for this resource, if any.
11060        '''
11061        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11062        '''
11063         Tags is a map of key, value pairs.
11064        '''
11065        self.username = username if username is not None else ''
11066
11067    def __repr__(self):
11068        return '<sdm.Snowflake ' + \
11069            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11070            'database: ' + repr(self.database) + ' ' +\
11071            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11072            'healthy: ' + repr(self.healthy) + ' ' +\
11073            'hostname: ' + repr(self.hostname) + ' ' +\
11074            'id: ' + repr(self.id) + ' ' +\
11075            'name: ' + repr(self.name) + ' ' +\
11076            'password: ' + repr(self.password) + ' ' +\
11077            'port_override: ' + repr(self.port_override) + ' ' +\
11078            'schema: ' + repr(self.schema) + ' ' +\
11079            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11080            'tags: ' + repr(self.tags) + ' ' +\
11081            'username: ' + repr(self.username) + ' ' +\
11082            '>'
11083
11084    def to_dict(self):
11085        return {
11086            'bind_interface': self.bind_interface,
11087            'database': self.database,
11088            'egress_filter': self.egress_filter,
11089            'healthy': self.healthy,
11090            'hostname': self.hostname,
11091            'id': self.id,
11092            'name': self.name,
11093            'password': self.password,
11094            'port_override': self.port_override,
11095            'schema': self.schema,
11096            'secret_store_id': self.secret_store_id,
11097            'tags': self.tags,
11098            'username': self.username,
11099        }
11100
11101    @classmethod
11102    def from_dict(cls, d):
11103        return cls(
11104            bind_interface=d.get('bind_interface'),
11105            database=d.get('database'),
11106            egress_filter=d.get('egress_filter'),
11107            healthy=d.get('healthy'),
11108            hostname=d.get('hostname'),
11109            id=d.get('id'),
11110            name=d.get('name'),
11111            password=d.get('password'),
11112            port_override=d.get('port_override'),
11113            schema=d.get('schema'),
11114            secret_store_id=d.get('secret_store_id'),
11115            tags=d.get('tags'),
11116            username=d.get('username'),
11117        )
11118
11119
11120class Sybase:
11121    __slots__ = [
11122        'bind_interface',
11123        'egress_filter',
11124        'healthy',
11125        'hostname',
11126        'id',
11127        'name',
11128        'password',
11129        'port',
11130        'port_override',
11131        'secret_store_id',
11132        'tags',
11133        'username',
11134    ]
11135
11136    def __init__(
11137        self,
11138        bind_interface=None,
11139        egress_filter=None,
11140        healthy=None,
11141        hostname=None,
11142        id=None,
11143        name=None,
11144        password=None,
11145        port=None,
11146        port_override=None,
11147        secret_store_id=None,
11148        tags=None,
11149        username=None,
11150    ):
11151        self.bind_interface = bind_interface if bind_interface is not None else ''
11152        '''
11153         Bind interface
11154        '''
11155        self.egress_filter = egress_filter if egress_filter is not None else ''
11156        '''
11157         A filter applied to the routing logic to pin datasource to nodes.
11158        '''
11159        self.healthy = healthy if healthy is not None else False
11160        '''
11161         True if the datasource is reachable and the credentials are valid.
11162        '''
11163        self.hostname = hostname if hostname is not None else ''
11164        self.id = id if id is not None else ''
11165        '''
11166         Unique identifier of the Resource.
11167        '''
11168        self.name = name if name is not None else ''
11169        '''
11170         Unique human-readable name of the Resource.
11171        '''
11172        self.password = password if password is not None else ''
11173        self.port = port if port is not None else 0
11174        self.port_override = port_override if port_override is not None else 0
11175        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11176        '''
11177         ID of the secret store containing credentials for this resource, if any.
11178        '''
11179        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11180        '''
11181         Tags is a map of key, value pairs.
11182        '''
11183        self.username = username if username is not None else ''
11184
11185    def __repr__(self):
11186        return '<sdm.Sybase ' + \
11187            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11188            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11189            'healthy: ' + repr(self.healthy) + ' ' +\
11190            'hostname: ' + repr(self.hostname) + ' ' +\
11191            'id: ' + repr(self.id) + ' ' +\
11192            'name: ' + repr(self.name) + ' ' +\
11193            'password: ' + repr(self.password) + ' ' +\
11194            'port: ' + repr(self.port) + ' ' +\
11195            'port_override: ' + repr(self.port_override) + ' ' +\
11196            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11197            'tags: ' + repr(self.tags) + ' ' +\
11198            'username: ' + repr(self.username) + ' ' +\
11199            '>'
11200
11201    def to_dict(self):
11202        return {
11203            'bind_interface': self.bind_interface,
11204            'egress_filter': self.egress_filter,
11205            'healthy': self.healthy,
11206            'hostname': self.hostname,
11207            'id': self.id,
11208            'name': self.name,
11209            'password': self.password,
11210            'port': self.port,
11211            'port_override': self.port_override,
11212            'secret_store_id': self.secret_store_id,
11213            'tags': self.tags,
11214            'username': self.username,
11215        }
11216
11217    @classmethod
11218    def from_dict(cls, d):
11219        return cls(
11220            bind_interface=d.get('bind_interface'),
11221            egress_filter=d.get('egress_filter'),
11222            healthy=d.get('healthy'),
11223            hostname=d.get('hostname'),
11224            id=d.get('id'),
11225            name=d.get('name'),
11226            password=d.get('password'),
11227            port=d.get('port'),
11228            port_override=d.get('port_override'),
11229            secret_store_id=d.get('secret_store_id'),
11230            tags=d.get('tags'),
11231            username=d.get('username'),
11232        )
11233
11234
11235class SybaseIQ:
11236    __slots__ = [
11237        'bind_interface',
11238        'egress_filter',
11239        'healthy',
11240        'hostname',
11241        'id',
11242        'name',
11243        'password',
11244        'port',
11245        'port_override',
11246        'secret_store_id',
11247        'tags',
11248        'username',
11249    ]
11250
11251    def __init__(
11252        self,
11253        bind_interface=None,
11254        egress_filter=None,
11255        healthy=None,
11256        hostname=None,
11257        id=None,
11258        name=None,
11259        password=None,
11260        port=None,
11261        port_override=None,
11262        secret_store_id=None,
11263        tags=None,
11264        username=None,
11265    ):
11266        self.bind_interface = bind_interface if bind_interface is not None else ''
11267        '''
11268         Bind interface
11269        '''
11270        self.egress_filter = egress_filter if egress_filter is not None else ''
11271        '''
11272         A filter applied to the routing logic to pin datasource to nodes.
11273        '''
11274        self.healthy = healthy if healthy is not None else False
11275        '''
11276         True if the datasource is reachable and the credentials are valid.
11277        '''
11278        self.hostname = hostname if hostname is not None else ''
11279        self.id = id if id is not None else ''
11280        '''
11281         Unique identifier of the Resource.
11282        '''
11283        self.name = name if name is not None else ''
11284        '''
11285         Unique human-readable name of the Resource.
11286        '''
11287        self.password = password if password is not None else ''
11288        self.port = port if port is not None else 0
11289        self.port_override = port_override if port_override is not None else 0
11290        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11291        '''
11292         ID of the secret store containing credentials for this resource, if any.
11293        '''
11294        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11295        '''
11296         Tags is a map of key, value pairs.
11297        '''
11298        self.username = username if username is not None else ''
11299
11300    def __repr__(self):
11301        return '<sdm.SybaseIQ ' + \
11302            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11303            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11304            'healthy: ' + repr(self.healthy) + ' ' +\
11305            'hostname: ' + repr(self.hostname) + ' ' +\
11306            'id: ' + repr(self.id) + ' ' +\
11307            'name: ' + repr(self.name) + ' ' +\
11308            'password: ' + repr(self.password) + ' ' +\
11309            'port: ' + repr(self.port) + ' ' +\
11310            'port_override: ' + repr(self.port_override) + ' ' +\
11311            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11312            'tags: ' + repr(self.tags) + ' ' +\
11313            'username: ' + repr(self.username) + ' ' +\
11314            '>'
11315
11316    def to_dict(self):
11317        return {
11318            'bind_interface': self.bind_interface,
11319            'egress_filter': self.egress_filter,
11320            'healthy': self.healthy,
11321            'hostname': self.hostname,
11322            'id': self.id,
11323            'name': self.name,
11324            'password': self.password,
11325            'port': self.port,
11326            'port_override': self.port_override,
11327            'secret_store_id': self.secret_store_id,
11328            'tags': self.tags,
11329            'username': self.username,
11330        }
11331
11332    @classmethod
11333    def from_dict(cls, d):
11334        return cls(
11335            bind_interface=d.get('bind_interface'),
11336            egress_filter=d.get('egress_filter'),
11337            healthy=d.get('healthy'),
11338            hostname=d.get('hostname'),
11339            id=d.get('id'),
11340            name=d.get('name'),
11341            password=d.get('password'),
11342            port=d.get('port'),
11343            port_override=d.get('port_override'),
11344            secret_store_id=d.get('secret_store_id'),
11345            tags=d.get('tags'),
11346            username=d.get('username'),
11347        )
11348
11349
11350class Tag:
11351    __slots__ = [
11352        'name',
11353        'value',
11354    ]
11355
11356    def __init__(
11357        self,
11358        name=None,
11359        value=None,
11360    ):
11361        self.name = name if name is not None else ''
11362        self.value = value if value is not None else ''
11363
11364    def __repr__(self):
11365        return '<sdm.Tag ' + \
11366            'name: ' + repr(self.name) + ' ' +\
11367            'value: ' + repr(self.value) + ' ' +\
11368            '>'
11369
11370    def to_dict(self):
11371        return {
11372            'name': self.name,
11373            'value': self.value,
11374        }
11375
11376    @classmethod
11377    def from_dict(cls, d):
11378        return cls(
11379            name=d.get('name'),
11380            value=d.get('value'),
11381        )
11382
11383
11384class Teradata:
11385    __slots__ = [
11386        'bind_interface',
11387        'egress_filter',
11388        'healthy',
11389        'hostname',
11390        'id',
11391        'name',
11392        'password',
11393        'port',
11394        'port_override',
11395        'secret_store_id',
11396        'tags',
11397        'username',
11398    ]
11399
11400    def __init__(
11401        self,
11402        bind_interface=None,
11403        egress_filter=None,
11404        healthy=None,
11405        hostname=None,
11406        id=None,
11407        name=None,
11408        password=None,
11409        port=None,
11410        port_override=None,
11411        secret_store_id=None,
11412        tags=None,
11413        username=None,
11414    ):
11415        self.bind_interface = bind_interface if bind_interface is not None else ''
11416        '''
11417         Bind interface
11418        '''
11419        self.egress_filter = egress_filter if egress_filter is not None else ''
11420        '''
11421         A filter applied to the routing logic to pin datasource to nodes.
11422        '''
11423        self.healthy = healthy if healthy is not None else False
11424        '''
11425         True if the datasource is reachable and the credentials are valid.
11426        '''
11427        self.hostname = hostname if hostname is not None else ''
11428        self.id = id if id is not None else ''
11429        '''
11430         Unique identifier of the Resource.
11431        '''
11432        self.name = name if name is not None else ''
11433        '''
11434         Unique human-readable name of the Resource.
11435        '''
11436        self.password = password if password is not None else ''
11437        self.port = port if port is not None else 0
11438        self.port_override = port_override if port_override is not None else 0
11439        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11440        '''
11441         ID of the secret store containing credentials for this resource, if any.
11442        '''
11443        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11444        '''
11445         Tags is a map of key, value pairs.
11446        '''
11447        self.username = username if username is not None else ''
11448
11449    def __repr__(self):
11450        return '<sdm.Teradata ' + \
11451            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11452            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11453            'healthy: ' + repr(self.healthy) + ' ' +\
11454            'hostname: ' + repr(self.hostname) + ' ' +\
11455            'id: ' + repr(self.id) + ' ' +\
11456            'name: ' + repr(self.name) + ' ' +\
11457            'password: ' + repr(self.password) + ' ' +\
11458            'port: ' + repr(self.port) + ' ' +\
11459            'port_override: ' + repr(self.port_override) + ' ' +\
11460            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11461            'tags: ' + repr(self.tags) + ' ' +\
11462            'username: ' + repr(self.username) + ' ' +\
11463            '>'
11464
11465    def to_dict(self):
11466        return {
11467            'bind_interface': self.bind_interface,
11468            'egress_filter': self.egress_filter,
11469            'healthy': self.healthy,
11470            'hostname': self.hostname,
11471            'id': self.id,
11472            'name': self.name,
11473            'password': self.password,
11474            'port': self.port,
11475            'port_override': self.port_override,
11476            'secret_store_id': self.secret_store_id,
11477            'tags': self.tags,
11478            'username': self.username,
11479        }
11480
11481    @classmethod
11482    def from_dict(cls, d):
11483        return cls(
11484            bind_interface=d.get('bind_interface'),
11485            egress_filter=d.get('egress_filter'),
11486            healthy=d.get('healthy'),
11487            hostname=d.get('hostname'),
11488            id=d.get('id'),
11489            name=d.get('name'),
11490            password=d.get('password'),
11491            port=d.get('port'),
11492            port_override=d.get('port_override'),
11493            secret_store_id=d.get('secret_store_id'),
11494            tags=d.get('tags'),
11495            username=d.get('username'),
11496        )
11497
11498
11499class UpdateResponseMetadata:
11500    '''
11501         UpdateResponseMetadata is reserved for future use.
11502    '''
11503    __slots__ = []
11504
11505    def __init__(self, ):
11506        pass
11507
11508    def __repr__(self):
11509        return '<sdm.UpdateResponseMetadata ' + \
11510            '>'
11511
11512    def to_dict(self):
11513        return {}
11514
11515    @classmethod
11516    def from_dict(cls, d):
11517        return cls()
11518
11519
11520class User:
11521    '''
11522         A User can connect to resources they are granted directly, or granted
11523     via roles.
11524    '''
11525    __slots__ = [
11526        'email',
11527        'first_name',
11528        'id',
11529        'last_name',
11530        'suspended',
11531        'tags',
11532    ]
11533
11534    def __init__(
11535        self,
11536        email=None,
11537        first_name=None,
11538        id=None,
11539        last_name=None,
11540        suspended=None,
11541        tags=None,
11542    ):
11543        self.email = email if email is not None else ''
11544        '''
11545         The User's email address. Must be unique.
11546        '''
11547        self.first_name = first_name if first_name is not None else ''
11548        '''
11549         The User's first name.
11550        '''
11551        self.id = id if id is not None else ''
11552        '''
11553         Unique identifier of the User.
11554        '''
11555        self.last_name = last_name if last_name is not None else ''
11556        '''
11557         The User's last name.
11558        '''
11559        self.suspended = suspended if suspended is not None else False
11560        '''
11561         The User's suspended state.
11562        '''
11563        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11564        '''
11565         Tags is a map of key, value pairs.
11566        '''
11567
11568    def __repr__(self):
11569        return '<sdm.User ' + \
11570            'email: ' + repr(self.email) + ' ' +\
11571            'first_name: ' + repr(self.first_name) + ' ' +\
11572            'id: ' + repr(self.id) + ' ' +\
11573            'last_name: ' + repr(self.last_name) + ' ' +\
11574            'suspended: ' + repr(self.suspended) + ' ' +\
11575            'tags: ' + repr(self.tags) + ' ' +\
11576            '>'
11577
11578    def to_dict(self):
11579        return {
11580            'email': self.email,
11581            'first_name': self.first_name,
11582            'id': self.id,
11583            'last_name': self.last_name,
11584            'suspended': self.suspended,
11585            'tags': self.tags,
11586        }
11587
11588    @classmethod
11589    def from_dict(cls, d):
11590        return cls(
11591            email=d.get('email'),
11592            first_name=d.get('first_name'),
11593            id=d.get('id'),
11594            last_name=d.get('last_name'),
11595            suspended=d.get('suspended'),
11596            tags=d.get('tags'),
11597        )
11598
11599
11600class VaultAppRoleStore:
11601    __slots__ = [
11602        'id',
11603        'name',
11604        'namespace',
11605        'server_address',
11606        'tags',
11607    ]
11608
11609    def __init__(
11610        self,
11611        id=None,
11612        name=None,
11613        namespace=None,
11614        server_address=None,
11615        tags=None,
11616    ):
11617        self.id = id if id is not None else ''
11618        '''
11619         Unique identifier of the SecretStore.
11620        '''
11621        self.name = name if name is not None else ''
11622        '''
11623         Unique human-readable name of the SecretStore.
11624        '''
11625        self.namespace = namespace if namespace is not None else ''
11626        self.server_address = server_address if server_address is not None else ''
11627        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11628        '''
11629         Tags is a map of key, value pairs.
11630        '''
11631
11632    def __repr__(self):
11633        return '<sdm.VaultAppRoleStore ' + \
11634            'id: ' + repr(self.id) + ' ' +\
11635            'name: ' + repr(self.name) + ' ' +\
11636            'namespace: ' + repr(self.namespace) + ' ' +\
11637            'server_address: ' + repr(self.server_address) + ' ' +\
11638            'tags: ' + repr(self.tags) + ' ' +\
11639            '>'
11640
11641    def to_dict(self):
11642        return {
11643            'id': self.id,
11644            'name': self.name,
11645            'namespace': self.namespace,
11646            'server_address': self.server_address,
11647            'tags': self.tags,
11648        }
11649
11650    @classmethod
11651    def from_dict(cls, d):
11652        return cls(
11653            id=d.get('id'),
11654            name=d.get('name'),
11655            namespace=d.get('namespace'),
11656            server_address=d.get('server_address'),
11657            tags=d.get('tags'),
11658        )
11659
11660
11661class VaultTLSStore:
11662    __slots__ = [
11663        'ca_cert_path',
11664        'client_cert_path',
11665        'client_key_path',
11666        'id',
11667        'name',
11668        'namespace',
11669        'server_address',
11670        'tags',
11671    ]
11672
11673    def __init__(
11674        self,
11675        ca_cert_path=None,
11676        client_cert_path=None,
11677        client_key_path=None,
11678        id=None,
11679        name=None,
11680        namespace=None,
11681        server_address=None,
11682        tags=None,
11683    ):
11684        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
11685        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
11686        self.client_key_path = client_key_path if client_key_path is not None else ''
11687        self.id = id if id is not None else ''
11688        '''
11689         Unique identifier of the SecretStore.
11690        '''
11691        self.name = name if name is not None else ''
11692        '''
11693         Unique human-readable name of the SecretStore.
11694        '''
11695        self.namespace = namespace if namespace is not None else ''
11696        self.server_address = server_address if server_address is not None else ''
11697        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11698        '''
11699         Tags is a map of key, value pairs.
11700        '''
11701
11702    def __repr__(self):
11703        return '<sdm.VaultTLSStore ' + \
11704            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
11705            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
11706            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
11707            'id: ' + repr(self.id) + ' ' +\
11708            'name: ' + repr(self.name) + ' ' +\
11709            'namespace: ' + repr(self.namespace) + ' ' +\
11710            'server_address: ' + repr(self.server_address) + ' ' +\
11711            'tags: ' + repr(self.tags) + ' ' +\
11712            '>'
11713
11714    def to_dict(self):
11715        return {
11716            'ca_cert_path': self.ca_cert_path,
11717            'client_cert_path': self.client_cert_path,
11718            'client_key_path': self.client_key_path,
11719            'id': self.id,
11720            'name': self.name,
11721            'namespace': self.namespace,
11722            'server_address': self.server_address,
11723            'tags': self.tags,
11724        }
11725
11726    @classmethod
11727    def from_dict(cls, d):
11728        return cls(
11729            ca_cert_path=d.get('ca_cert_path'),
11730            client_cert_path=d.get('client_cert_path'),
11731            client_key_path=d.get('client_key_path'),
11732            id=d.get('id'),
11733            name=d.get('name'),
11734            namespace=d.get('namespace'),
11735            server_address=d.get('server_address'),
11736            tags=d.get('tags'),
11737        )
11738
11739
11740class VaultTokenStore:
11741    __slots__ = [
11742        'id',
11743        'name',
11744        'namespace',
11745        'server_address',
11746        'tags',
11747    ]
11748
11749    def __init__(
11750        self,
11751        id=None,
11752        name=None,
11753        namespace=None,
11754        server_address=None,
11755        tags=None,
11756    ):
11757        self.id = id if id is not None else ''
11758        '''
11759         Unique identifier of the SecretStore.
11760        '''
11761        self.name = name if name is not None else ''
11762        '''
11763         Unique human-readable name of the SecretStore.
11764        '''
11765        self.namespace = namespace if namespace is not None else ''
11766        self.server_address = server_address if server_address is not None else ''
11767        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11768        '''
11769         Tags is a map of key, value pairs.
11770        '''
11771
11772    def __repr__(self):
11773        return '<sdm.VaultTokenStore ' + \
11774            'id: ' + repr(self.id) + ' ' +\
11775            'name: ' + repr(self.name) + ' ' +\
11776            'namespace: ' + repr(self.namespace) + ' ' +\
11777            'server_address: ' + repr(self.server_address) + ' ' +\
11778            'tags: ' + repr(self.tags) + ' ' +\
11779            '>'
11780
11781    def to_dict(self):
11782        return {
11783            'id': self.id,
11784            'name': self.name,
11785            'namespace': self.namespace,
11786            'server_address': self.server_address,
11787            'tags': self.tags,
11788        }
11789
11790    @classmethod
11791    def from_dict(cls, d):
11792        return cls(
11793            id=d.get('id'),
11794            name=d.get('name'),
11795            namespace=d.get('namespace'),
11796            server_address=d.get('server_address'),
11797            tags=d.get('tags'),
11798        )
11799
11800
11801def _porcelain_zero_value_tags():
11802    return {}
11803
11804
11805def _porcelain_zero_value_access_rules():
11806    return []
class AKS:
 22class AKS:
 23    __slots__ = [
 24        'bind_interface',
 25        'certificate_authority',
 26        'client_certificate',
 27        'client_key',
 28        'egress_filter',
 29        'healthcheck_namespace',
 30        'healthy',
 31        'hostname',
 32        'id',
 33        'name',
 34        'port',
 35        'port_override',
 36        'remote_identity_group_id',
 37        'remote_identity_healthcheck_username',
 38        'secret_store_id',
 39        'tags',
 40    ]
 41
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
101
102    def __repr__(self):
103        return '<sdm.AKS ' + \
104            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
105            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
106            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
107            'client_key: ' + repr(self.client_key) + ' ' +\
108            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
109            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
110            'healthy: ' + repr(self.healthy) + ' ' +\
111            'hostname: ' + repr(self.hostname) + ' ' +\
112            'id: ' + repr(self.id) + ' ' +\
113            'name: ' + repr(self.name) + ' ' +\
114            'port: ' + repr(self.port) + ' ' +\
115            'port_override: ' + repr(self.port_override) + ' ' +\
116            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
117            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
118            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
119            'tags: ' + repr(self.tags) + ' ' +\
120            '>'
121
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
142
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
@classmethod
def from_dict(cls, d)
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
class AKSBasicAuth:
166class AKSBasicAuth:
167    __slots__ = [
168        'bind_interface',
169        'egress_filter',
170        'healthcheck_namespace',
171        'healthy',
172        'hostname',
173        'id',
174        'name',
175        'password',
176        'port',
177        'port_override',
178        'secret_store_id',
179        'tags',
180        'username',
181    ]
182
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
236
237    def __repr__(self):
238        return '<sdm.AKSBasicAuth ' + \
239            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
240            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
241            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
242            'healthy: ' + repr(self.healthy) + ' ' +\
243            'hostname: ' + repr(self.hostname) + ' ' +\
244            'id: ' + repr(self.id) + ' ' +\
245            'name: ' + repr(self.name) + ' ' +\
246            'password: ' + repr(self.password) + ' ' +\
247            'port: ' + repr(self.port) + ' ' +\
248            'port_override: ' + repr(self.port_override) + ' ' +\
249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
250            'tags: ' + repr(self.tags) + ' ' +\
251            'username: ' + repr(self.username) + ' ' +\
252            '>'
253
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
270
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
@classmethod
def from_dict(cls, d)
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
class AKSServiceAccount:
290class AKSServiceAccount:
291    __slots__ = [
292        'bind_interface',
293        'egress_filter',
294        'healthcheck_namespace',
295        'healthy',
296        'hostname',
297        'id',
298        'name',
299        'port',
300        'port_override',
301        'remote_identity_group_id',
302        'remote_identity_healthcheck_username',
303        'secret_store_id',
304        'tags',
305        'token',
306    ]
307
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
363
364    def __repr__(self):
365        return '<sdm.AKSServiceAccount ' + \
366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
367            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
368            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
369            'healthy: ' + repr(self.healthy) + ' ' +\
370            'hostname: ' + repr(self.hostname) + ' ' +\
371            'id: ' + repr(self.id) + ' ' +\
372            'name: ' + repr(self.name) + ' ' +\
373            'port: ' + repr(self.port) + ' ' +\
374            'port_override: ' + repr(self.port_override) + ' ' +\
375            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
376            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
377            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
378            'tags: ' + repr(self.tags) + ' ' +\
379            'token: ' + repr(self.token) + ' ' +\
380            '>'
381
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
400
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
@classmethod
def from_dict(cls, d)
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
class AKSServiceAccountUserImpersonation:
422class AKSServiceAccountUserImpersonation:
423    __slots__ = [
424        'bind_interface',
425        'egress_filter',
426        'healthcheck_namespace',
427        'healthy',
428        'hostname',
429        'id',
430        'name',
431        'port',
432        'port_override',
433        'secret_store_id',
434        'tags',
435        'token',
436    ]
437
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
489
490    def __repr__(self):
491        return '<sdm.AKSServiceAccountUserImpersonation ' + \
492            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
493            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
494            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
495            'healthy: ' + repr(self.healthy) + ' ' +\
496            'hostname: ' + repr(self.hostname) + ' ' +\
497            'id: ' + repr(self.id) + ' ' +\
498            'name: ' + repr(self.name) + ' ' +\
499            'port: ' + repr(self.port) + ' ' +\
500            'port_override: ' + repr(self.port_override) + ' ' +\
501            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
502            'tags: ' + repr(self.tags) + ' ' +\
503            'token: ' + repr(self.token) + ' ' +\
504            '>'
505
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
521
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
@classmethod
def from_dict(cls, d)
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
class AKSUserImpersonation:
540class AKSUserImpersonation:
541    __slots__ = [
542        'bind_interface',
543        'certificate_authority',
544        'client_certificate',
545        'client_key',
546        'egress_filter',
547        'healthcheck_namespace',
548        'healthy',
549        'hostname',
550        'id',
551        'name',
552        'port',
553        'port_override',
554        'secret_store_id',
555        'tags',
556    ]
557
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
613
614    def __repr__(self):
615        return '<sdm.AKSUserImpersonation ' + \
616            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
617            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
618            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
619            'client_key: ' + repr(self.client_key) + ' ' +\
620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
621            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
622            'healthy: ' + repr(self.healthy) + ' ' +\
623            'hostname: ' + repr(self.hostname) + ' ' +\
624            'id: ' + repr(self.id) + ' ' +\
625            'name: ' + repr(self.name) + ' ' +\
626            'port: ' + repr(self.port) + ' ' +\
627            'port_override: ' + repr(self.port_override) + ' ' +\
628            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
629            'tags: ' + repr(self.tags) + ' ' +\
630            '>'
631
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
649
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
@classmethod
def from_dict(cls, d)
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
class AWS:
670class AWS:
671    __slots__ = [
672        'access_key',
673        'bind_interface',
674        'egress_filter',
675        'healthcheck_region',
676        'healthy',
677        'id',
678        'name',
679        'role_arn',
680        'role_external_id',
681        'secret_access_key',
682        'secret_store_id',
683        'tags',
684    ]
685
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
734
735    def __repr__(self):
736        return '<sdm.AWS ' + \
737            'access_key: ' + repr(self.access_key) + ' ' +\
738            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
739            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
740            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
741            'healthy: ' + repr(self.healthy) + ' ' +\
742            'id: ' + repr(self.id) + ' ' +\
743            'name: ' + repr(self.name) + ' ' +\
744            'role_arn: ' + repr(self.role_arn) + ' ' +\
745            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
746            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
747            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
748            'tags: ' + repr(self.tags) + ' ' +\
749            '>'
750
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
766
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
@classmethod
def from_dict(cls, d)
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
class AWSStore:
785class AWSStore:
786    __slots__ = [
787        'id',
788        'name',
789        'region',
790        'tags',
791    ]
792
793    def __init__(
794        self,
795        id=None,
796        name=None,
797        region=None,
798        tags=None,
799    ):
800        self.id = id if id is not None else ''
801        '''
802         Unique identifier of the SecretStore.
803        '''
804        self.name = name if name is not None else ''
805        '''
806         Unique human-readable name of the SecretStore.
807        '''
808        self.region = region if region is not None else ''
809        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
810        '''
811         Tags is a map of key, value pairs.
812        '''
813
814    def __repr__(self):
815        return '<sdm.AWSStore ' + \
816            'id: ' + repr(self.id) + ' ' +\
817            'name: ' + repr(self.name) + ' ' +\
818            'region: ' + repr(self.region) + ' ' +\
819            'tags: ' + repr(self.tags) + ' ' +\
820            '>'
821
822    def to_dict(self):
823        return {
824            'id': self.id,
825            'name': self.name,
826            'region': self.region,
827            'tags': self.tags,
828        }
829
830    @classmethod
831    def from_dict(cls, d):
832        return cls(
833            id=d.get('id'),
834            name=d.get('name'),
835            region=d.get('region'),
836            tags=d.get('tags'),
837        )
AWSStore(id=None, name=None, region=None, tags=None)
793    def __init__(
794        self,
795        id=None,
796        name=None,
797        region=None,
798        tags=None,
799    ):
800        self.id = id if id is not None else ''
801        '''
802         Unique identifier of the SecretStore.
803        '''
804        self.name = name if name is not None else ''
805        '''
806         Unique human-readable name of the SecretStore.
807        '''
808        self.region = region if region is not None else ''
809        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
810        '''
811         Tags is a map of key, value pairs.
812        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
822    def to_dict(self):
823        return {
824            'id': self.id,
825            'name': self.name,
826            'region': self.region,
827            'tags': self.tags,
828        }
@classmethod
def from_dict(cls, d)
830    @classmethod
831    def from_dict(cls, d):
832        return cls(
833            id=d.get('id'),
834            name=d.get('name'),
835            region=d.get('region'),
836            tags=d.get('tags'),
837        )
class AccountAttachment:
840class AccountAttachment:
841    '''
842         AccountAttachments assign an account to a role.
843    '''
844    __slots__ = [
845        'account_id',
846        'id',
847        'role_id',
848    ]
849
850    def __init__(
851        self,
852        account_id=None,
853        id=None,
854        role_id=None,
855    ):
856        self.account_id = account_id if account_id is not None else ''
857        '''
858         The id of the account of this AccountAttachment.
859        '''
860        self.id = id if id is not None else ''
861        '''
862         Unique identifier of the AccountAttachment.
863        '''
864        self.role_id = role_id if role_id is not None else ''
865        '''
866         The id of the attached role of this AccountAttachment.
867        '''
868
869    def __repr__(self):
870        return '<sdm.AccountAttachment ' + \
871            'account_id: ' + repr(self.account_id) + ' ' +\
872            'id: ' + repr(self.id) + ' ' +\
873            'role_id: ' + repr(self.role_id) + ' ' +\
874            '>'
875
876    def to_dict(self):
877        return {
878            'account_id': self.account_id,
879            'id': self.id,
880            'role_id': self.role_id,
881        }
882
883    @classmethod
884    def from_dict(cls, d):
885        return cls(
886            account_id=d.get('account_id'),
887            id=d.get('id'),
888            role_id=d.get('role_id'),
889        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
850    def __init__(
851        self,
852        account_id=None,
853        id=None,
854        role_id=None,
855    ):
856        self.account_id = account_id if account_id is not None else ''
857        '''
858         The id of the account of this AccountAttachment.
859        '''
860        self.id = id if id is not None else ''
861        '''
862         Unique identifier of the AccountAttachment.
863        '''
864        self.role_id = role_id if role_id is not None else ''
865        '''
866         The id of the attached role of this AccountAttachment.
867        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
876    def to_dict(self):
877        return {
878            'account_id': self.account_id,
879            'id': self.id,
880            'role_id': self.role_id,
881        }
@classmethod
def from_dict(cls, d)
883    @classmethod
884    def from_dict(cls, d):
885        return cls(
886            account_id=d.get('account_id'),
887            id=d.get('id'),
888            role_id=d.get('role_id'),
889        )
class AccountAttachmentCreateResponse:
892class AccountAttachmentCreateResponse:
893    '''
894         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
895    '''
896    __slots__ = [
897        'account_attachment',
898        'meta',
899        'rate_limit',
900    ]
901
902    def __init__(
903        self,
904        account_attachment=None,
905        meta=None,
906        rate_limit=None,
907    ):
908        self.account_attachment = account_attachment if account_attachment is not None else None
909        '''
910         The created AccountAttachment.
911        '''
912        self.meta = meta if meta is not None else None
913        '''
914         Reserved for future use.
915        '''
916        self.rate_limit = rate_limit if rate_limit is not None else None
917        '''
918         Rate limit information.
919        '''
920
921    def __repr__(self):
922        return '<sdm.AccountAttachmentCreateResponse ' + \
923            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
924            'meta: ' + repr(self.meta) + ' ' +\
925            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
926            '>'
927
928    def to_dict(self):
929        return {
930            'account_attachment': self.account_attachment,
931            'meta': self.meta,
932            'rate_limit': self.rate_limit,
933        }
934
935    @classmethod
936    def from_dict(cls, d):
937        return cls(
938            account_attachment=d.get('account_attachment'),
939            meta=d.get('meta'),
940            rate_limit=d.get('rate_limit'),
941        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
902    def __init__(
903        self,
904        account_attachment=None,
905        meta=None,
906        rate_limit=None,
907    ):
908        self.account_attachment = account_attachment if account_attachment is not None else None
909        '''
910         The created AccountAttachment.
911        '''
912        self.meta = meta if meta is not None else None
913        '''
914         Reserved for future use.
915        '''
916        self.rate_limit = rate_limit if rate_limit is not None else None
917        '''
918         Rate limit information.
919        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
928    def to_dict(self):
929        return {
930            'account_attachment': self.account_attachment,
931            'meta': self.meta,
932            'rate_limit': self.rate_limit,
933        }
@classmethod
def from_dict(cls, d)
935    @classmethod
936    def from_dict(cls, d):
937        return cls(
938            account_attachment=d.get('account_attachment'),
939            meta=d.get('meta'),
940            rate_limit=d.get('rate_limit'),
941        )
class AccountAttachmentDeleteResponse:
944class AccountAttachmentDeleteResponse:
945    '''
946         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
947    '''
948    __slots__ = [
949        'meta',
950        'rate_limit',
951    ]
952
953    def __init__(
954        self,
955        meta=None,
956        rate_limit=None,
957    ):
958        self.meta = meta if meta is not None else None
959        '''
960         Reserved for future use.
961        '''
962        self.rate_limit = rate_limit if rate_limit is not None else None
963        '''
964         Rate limit information.
965        '''
966
967    def __repr__(self):
968        return '<sdm.AccountAttachmentDeleteResponse ' + \
969            'meta: ' + repr(self.meta) + ' ' +\
970            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
971            '>'
972
973    def to_dict(self):
974        return {
975            'meta': self.meta,
976            'rate_limit': self.rate_limit,
977        }
978
979    @classmethod
980    def from_dict(cls, d):
981        return cls(
982            meta=d.get('meta'),
983            rate_limit=d.get('rate_limit'),
984        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
953    def __init__(
954        self,
955        meta=None,
956        rate_limit=None,
957    ):
958        self.meta = meta if meta is not None else None
959        '''
960         Reserved for future use.
961        '''
962        self.rate_limit = rate_limit if rate_limit is not None else None
963        '''
964         Rate limit information.
965        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
973    def to_dict(self):
974        return {
975            'meta': self.meta,
976            'rate_limit': self.rate_limit,
977        }
@classmethod
def from_dict(cls, d)
979    @classmethod
980    def from_dict(cls, d):
981        return cls(
982            meta=d.get('meta'),
983            rate_limit=d.get('rate_limit'),
984        )
class AccountAttachmentGetResponse:
 987class AccountAttachmentGetResponse:
 988    '''
 989         AccountAttachmentGetResponse returns a requested AccountAttachment.
 990    '''
 991    __slots__ = [
 992        'account_attachment',
 993        'meta',
 994        'rate_limit',
 995    ]
 996
 997    def __init__(
 998        self,
 999        account_attachment=None,
1000        meta=None,
1001        rate_limit=None,
1002    ):
1003        self.account_attachment = account_attachment if account_attachment is not None else None
1004        '''
1005         The requested AccountAttachment.
1006        '''
1007        self.meta = meta if meta is not None else None
1008        '''
1009         Reserved for future use.
1010        '''
1011        self.rate_limit = rate_limit if rate_limit is not None else None
1012        '''
1013         Rate limit information.
1014        '''
1015
1016    def __repr__(self):
1017        return '<sdm.AccountAttachmentGetResponse ' + \
1018            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1019            'meta: ' + repr(self.meta) + ' ' +\
1020            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1021            '>'
1022
1023    def to_dict(self):
1024        return {
1025            'account_attachment': self.account_attachment,
1026            'meta': self.meta,
1027            'rate_limit': self.rate_limit,
1028        }
1029
1030    @classmethod
1031    def from_dict(cls, d):
1032        return cls(
1033            account_attachment=d.get('account_attachment'),
1034            meta=d.get('meta'),
1035            rate_limit=d.get('rate_limit'),
1036        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
 997    def __init__(
 998        self,
 999        account_attachment=None,
1000        meta=None,
1001        rate_limit=None,
1002    ):
1003        self.account_attachment = account_attachment if account_attachment is not None else None
1004        '''
1005         The requested AccountAttachment.
1006        '''
1007        self.meta = meta if meta is not None else None
1008        '''
1009         Reserved for future use.
1010        '''
1011        self.rate_limit = rate_limit if rate_limit is not None else None
1012        '''
1013         Rate limit information.
1014        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1023    def to_dict(self):
1024        return {
1025            'account_attachment': self.account_attachment,
1026            'meta': self.meta,
1027            'rate_limit': self.rate_limit,
1028        }
@classmethod
def from_dict(cls, d)
1030    @classmethod
1031    def from_dict(cls, d):
1032        return cls(
1033            account_attachment=d.get('account_attachment'),
1034            meta=d.get('meta'),
1035            rate_limit=d.get('rate_limit'),
1036        )
class AccountCreateResponse:
1039class AccountCreateResponse:
1040    '''
1041         AccountCreateResponse reports how the Accounts were created in the system.
1042    '''
1043    __slots__ = [
1044        'account',
1045        'meta',
1046        'rate_limit',
1047        'token',
1048    ]
1049
1050    def __init__(
1051        self,
1052        account=None,
1053        meta=None,
1054        rate_limit=None,
1055        token=None,
1056    ):
1057        self.account = account if account is not None else None
1058        '''
1059         The created Account.
1060        '''
1061        self.meta = meta if meta is not None else None
1062        '''
1063         Reserved for future use.
1064        '''
1065        self.rate_limit = rate_limit if rate_limit is not None else None
1066        '''
1067         Rate limit information.
1068        '''
1069        self.token = token if token is not None else ''
1070        '''
1071         The auth token generated for the Account. The Account will use this token to
1072         authenticate with the strongDM API.
1073        '''
1074
1075    def __repr__(self):
1076        return '<sdm.AccountCreateResponse ' + \
1077            'account: ' + repr(self.account) + ' ' +\
1078            'meta: ' + repr(self.meta) + ' ' +\
1079            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1080            'token: ' + repr(self.token) + ' ' +\
1081            '>'
1082
1083    def to_dict(self):
1084        return {
1085            'account': self.account,
1086            'meta': self.meta,
1087            'rate_limit': self.rate_limit,
1088            'token': self.token,
1089        }
1090
1091    @classmethod
1092    def from_dict(cls, d):
1093        return cls(
1094            account=d.get('account'),
1095            meta=d.get('meta'),
1096            rate_limit=d.get('rate_limit'),
1097            token=d.get('token'),
1098        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1050    def __init__(
1051        self,
1052        account=None,
1053        meta=None,
1054        rate_limit=None,
1055        token=None,
1056    ):
1057        self.account = account if account is not None else None
1058        '''
1059         The created Account.
1060        '''
1061        self.meta = meta if meta is not None else None
1062        '''
1063         Reserved for future use.
1064        '''
1065        self.rate_limit = rate_limit if rate_limit is not None else None
1066        '''
1067         Rate limit information.
1068        '''
1069        self.token = token if token is not None else ''
1070        '''
1071         The auth token generated for the Account. The Account will use this token to
1072         authenticate with the strongDM API.
1073        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1083    def to_dict(self):
1084        return {
1085            'account': self.account,
1086            'meta': self.meta,
1087            'rate_limit': self.rate_limit,
1088            'token': self.token,
1089        }
@classmethod
def from_dict(cls, d)
1091    @classmethod
1092    def from_dict(cls, d):
1093        return cls(
1094            account=d.get('account'),
1095            meta=d.get('meta'),
1096            rate_limit=d.get('rate_limit'),
1097            token=d.get('token'),
1098        )
class AccountDeleteResponse:
1101class AccountDeleteResponse:
1102    '''
1103         AccountDeleteResponse returns information about a Account that was deleted.
1104    '''
1105    __slots__ = [
1106        'meta',
1107        'rate_limit',
1108    ]
1109
1110    def __init__(
1111        self,
1112        meta=None,
1113        rate_limit=None,
1114    ):
1115        self.meta = meta if meta is not None else None
1116        '''
1117         Reserved for future use.
1118        '''
1119        self.rate_limit = rate_limit if rate_limit is not None else None
1120        '''
1121         Rate limit information.
1122        '''
1123
1124    def __repr__(self):
1125        return '<sdm.AccountDeleteResponse ' + \
1126            'meta: ' + repr(self.meta) + ' ' +\
1127            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1128            '>'
1129
1130    def to_dict(self):
1131        return {
1132            'meta': self.meta,
1133            'rate_limit': self.rate_limit,
1134        }
1135
1136    @classmethod
1137    def from_dict(cls, d):
1138        return cls(
1139            meta=d.get('meta'),
1140            rate_limit=d.get('rate_limit'),
1141        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1110    def __init__(
1111        self,
1112        meta=None,
1113        rate_limit=None,
1114    ):
1115        self.meta = meta if meta is not None else None
1116        '''
1117         Reserved for future use.
1118        '''
1119        self.rate_limit = rate_limit if rate_limit is not None else None
1120        '''
1121         Rate limit information.
1122        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1130    def to_dict(self):
1131        return {
1132            'meta': self.meta,
1133            'rate_limit': self.rate_limit,
1134        }
@classmethod
def from_dict(cls, d)
1136    @classmethod
1137    def from_dict(cls, d):
1138        return cls(
1139            meta=d.get('meta'),
1140            rate_limit=d.get('rate_limit'),
1141        )
class AccountGetResponse:
1144class AccountGetResponse:
1145    '''
1146         AccountGetResponse returns a requested Account.
1147    '''
1148    __slots__ = [
1149        'account',
1150        'meta',
1151        'rate_limit',
1152    ]
1153
1154    def __init__(
1155        self,
1156        account=None,
1157        meta=None,
1158        rate_limit=None,
1159    ):
1160        self.account = account if account is not None else None
1161        '''
1162         The requested Account.
1163        '''
1164        self.meta = meta if meta is not None else None
1165        '''
1166         Reserved for future use.
1167        '''
1168        self.rate_limit = rate_limit if rate_limit is not None else None
1169        '''
1170         Rate limit information.
1171        '''
1172
1173    def __repr__(self):
1174        return '<sdm.AccountGetResponse ' + \
1175            'account: ' + repr(self.account) + ' ' +\
1176            'meta: ' + repr(self.meta) + ' ' +\
1177            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1178            '>'
1179
1180    def to_dict(self):
1181        return {
1182            'account': self.account,
1183            'meta': self.meta,
1184            'rate_limit': self.rate_limit,
1185        }
1186
1187    @classmethod
1188    def from_dict(cls, d):
1189        return cls(
1190            account=d.get('account'),
1191            meta=d.get('meta'),
1192            rate_limit=d.get('rate_limit'),
1193        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1154    def __init__(
1155        self,
1156        account=None,
1157        meta=None,
1158        rate_limit=None,
1159    ):
1160        self.account = account if account is not None else None
1161        '''
1162         The requested Account.
1163        '''
1164        self.meta = meta if meta is not None else None
1165        '''
1166         Reserved for future use.
1167        '''
1168        self.rate_limit = rate_limit if rate_limit is not None else None
1169        '''
1170         Rate limit information.
1171        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1180    def to_dict(self):
1181        return {
1182            'account': self.account,
1183            'meta': self.meta,
1184            'rate_limit': self.rate_limit,
1185        }
@classmethod
def from_dict(cls, d)
1187    @classmethod
1188    def from_dict(cls, d):
1189        return cls(
1190            account=d.get('account'),
1191            meta=d.get('meta'),
1192            rate_limit=d.get('rate_limit'),
1193        )
class AccountGrant:
1196class AccountGrant:
1197    '''
1198         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1199    '''
1200    __slots__ = [
1201        'account_id',
1202        'id',
1203        'resource_id',
1204        'start_from',
1205        'valid_until',
1206    ]
1207
1208    def __init__(
1209        self,
1210        account_id=None,
1211        id=None,
1212        resource_id=None,
1213        start_from=None,
1214        valid_until=None,
1215    ):
1216        self.account_id = account_id if account_id is not None else ''
1217        '''
1218         The account ID of this AccountGrant.
1219        '''
1220        self.id = id if id is not None else ''
1221        '''
1222         Unique identifier of the AccountGrant.
1223        '''
1224        self.resource_id = resource_id if resource_id is not None else ''
1225        '''
1226         The resource ID of this AccountGrant.
1227        '''
1228        self.start_from = start_from if start_from is not None else None
1229        '''
1230         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1231        '''
1232        self.valid_until = valid_until if valid_until is not None else None
1233        '''
1234         The timestamp when the resource grant will expire.
1235        '''
1236
1237    def __repr__(self):
1238        return '<sdm.AccountGrant ' + \
1239            'account_id: ' + repr(self.account_id) + ' ' +\
1240            'id: ' + repr(self.id) + ' ' +\
1241            'resource_id: ' + repr(self.resource_id) + ' ' +\
1242            'start_from: ' + repr(self.start_from) + ' ' +\
1243            'valid_until: ' + repr(self.valid_until) + ' ' +\
1244            '>'
1245
1246    def to_dict(self):
1247        return {
1248            'account_id': self.account_id,
1249            'id': self.id,
1250            'resource_id': self.resource_id,
1251            'start_from': self.start_from,
1252            'valid_until': self.valid_until,
1253        }
1254
1255    @classmethod
1256    def from_dict(cls, d):
1257        return cls(
1258            account_id=d.get('account_id'),
1259            id=d.get('id'),
1260            resource_id=d.get('resource_id'),
1261            start_from=d.get('start_from'),
1262            valid_until=d.get('valid_until'),
1263        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1208    def __init__(
1209        self,
1210        account_id=None,
1211        id=None,
1212        resource_id=None,
1213        start_from=None,
1214        valid_until=None,
1215    ):
1216        self.account_id = account_id if account_id is not None else ''
1217        '''
1218         The account ID of this AccountGrant.
1219        '''
1220        self.id = id if id is not None else ''
1221        '''
1222         Unique identifier of the AccountGrant.
1223        '''
1224        self.resource_id = resource_id if resource_id is not None else ''
1225        '''
1226         The resource ID of this AccountGrant.
1227        '''
1228        self.start_from = start_from if start_from is not None else None
1229        '''
1230         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1231        '''
1232        self.valid_until = valid_until if valid_until is not None else None
1233        '''
1234         The timestamp when the resource grant will expire.
1235        '''
account_id

The account ID of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource ID of this AccountGrant.

start_from

The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.

valid_until

The timestamp when the resource grant will expire.

def to_dict(self)
1246    def to_dict(self):
1247        return {
1248            'account_id': self.account_id,
1249            'id': self.id,
1250            'resource_id': self.resource_id,
1251            'start_from': self.start_from,
1252            'valid_until': self.valid_until,
1253        }
@classmethod
def from_dict(cls, d)
1255    @classmethod
1256    def from_dict(cls, d):
1257        return cls(
1258            account_id=d.get('account_id'),
1259            id=d.get('id'),
1260            resource_id=d.get('resource_id'),
1261            start_from=d.get('start_from'),
1262            valid_until=d.get('valid_until'),
1263        )
class AccountGrantCreateResponse:
1266class AccountGrantCreateResponse:
1267    '''
1268         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1269    '''
1270    __slots__ = [
1271        'account_grant',
1272        'meta',
1273        'rate_limit',
1274    ]
1275
1276    def __init__(
1277        self,
1278        account_grant=None,
1279        meta=None,
1280        rate_limit=None,
1281    ):
1282        self.account_grant = account_grant if account_grant is not None else None
1283        '''
1284         The created AccountGrant.
1285        '''
1286        self.meta = meta if meta is not None else None
1287        '''
1288         Reserved for future use.
1289        '''
1290        self.rate_limit = rate_limit if rate_limit is not None else None
1291        '''
1292         Rate limit information.
1293        '''
1294
1295    def __repr__(self):
1296        return '<sdm.AccountGrantCreateResponse ' + \
1297            'account_grant: ' + repr(self.account_grant) + ' ' +\
1298            'meta: ' + repr(self.meta) + ' ' +\
1299            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1300            '>'
1301
1302    def to_dict(self):
1303        return {
1304            'account_grant': self.account_grant,
1305            'meta': self.meta,
1306            'rate_limit': self.rate_limit,
1307        }
1308
1309    @classmethod
1310    def from_dict(cls, d):
1311        return cls(
1312            account_grant=d.get('account_grant'),
1313            meta=d.get('meta'),
1314            rate_limit=d.get('rate_limit'),
1315        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1276    def __init__(
1277        self,
1278        account_grant=None,
1279        meta=None,
1280        rate_limit=None,
1281    ):
1282        self.account_grant = account_grant if account_grant is not None else None
1283        '''
1284         The created AccountGrant.
1285        '''
1286        self.meta = meta if meta is not None else None
1287        '''
1288         Reserved for future use.
1289        '''
1290        self.rate_limit = rate_limit if rate_limit is not None else None
1291        '''
1292         Rate limit information.
1293        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1302    def to_dict(self):
1303        return {
1304            'account_grant': self.account_grant,
1305            'meta': self.meta,
1306            'rate_limit': self.rate_limit,
1307        }
@classmethod
def from_dict(cls, d)
1309    @classmethod
1310    def from_dict(cls, d):
1311        return cls(
1312            account_grant=d.get('account_grant'),
1313            meta=d.get('meta'),
1314            rate_limit=d.get('rate_limit'),
1315        )
class AccountGrantDeleteResponse:
1318class AccountGrantDeleteResponse:
1319    '''
1320         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1321    '''
1322    __slots__ = [
1323        'meta',
1324        'rate_limit',
1325    ]
1326
1327    def __init__(
1328        self,
1329        meta=None,
1330        rate_limit=None,
1331    ):
1332        self.meta = meta if meta is not None else None
1333        '''
1334         Reserved for future use.
1335        '''
1336        self.rate_limit = rate_limit if rate_limit is not None else None
1337        '''
1338         Rate limit information.
1339        '''
1340
1341    def __repr__(self):
1342        return '<sdm.AccountGrantDeleteResponse ' + \
1343            'meta: ' + repr(self.meta) + ' ' +\
1344            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1345            '>'
1346
1347    def to_dict(self):
1348        return {
1349            'meta': self.meta,
1350            'rate_limit': self.rate_limit,
1351        }
1352
1353    @classmethod
1354    def from_dict(cls, d):
1355        return cls(
1356            meta=d.get('meta'),
1357            rate_limit=d.get('rate_limit'),
1358        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1327    def __init__(
1328        self,
1329        meta=None,
1330        rate_limit=None,
1331    ):
1332        self.meta = meta if meta is not None else None
1333        '''
1334         Reserved for future use.
1335        '''
1336        self.rate_limit = rate_limit if rate_limit is not None else None
1337        '''
1338         Rate limit information.
1339        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1347    def to_dict(self):
1348        return {
1349            'meta': self.meta,
1350            'rate_limit': self.rate_limit,
1351        }
@classmethod
def from_dict(cls, d)
1353    @classmethod
1354    def from_dict(cls, d):
1355        return cls(
1356            meta=d.get('meta'),
1357            rate_limit=d.get('rate_limit'),
1358        )
class AccountGrantGetResponse:
1361class AccountGrantGetResponse:
1362    '''
1363         AccountGrantGetResponse returns a requested AccountGrant.
1364    '''
1365    __slots__ = [
1366        'account_grant',
1367        'meta',
1368        'rate_limit',
1369    ]
1370
1371    def __init__(
1372        self,
1373        account_grant=None,
1374        meta=None,
1375        rate_limit=None,
1376    ):
1377        self.account_grant = account_grant if account_grant is not None else None
1378        '''
1379         The requested AccountGrant.
1380        '''
1381        self.meta = meta if meta is not None else None
1382        '''
1383         Reserved for future use.
1384        '''
1385        self.rate_limit = rate_limit if rate_limit is not None else None
1386        '''
1387         Rate limit information.
1388        '''
1389
1390    def __repr__(self):
1391        return '<sdm.AccountGrantGetResponse ' + \
1392            'account_grant: ' + repr(self.account_grant) + ' ' +\
1393            'meta: ' + repr(self.meta) + ' ' +\
1394            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1395            '>'
1396
1397    def to_dict(self):
1398        return {
1399            'account_grant': self.account_grant,
1400            'meta': self.meta,
1401            'rate_limit': self.rate_limit,
1402        }
1403
1404    @classmethod
1405    def from_dict(cls, d):
1406        return cls(
1407            account_grant=d.get('account_grant'),
1408            meta=d.get('meta'),
1409            rate_limit=d.get('rate_limit'),
1410        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1371    def __init__(
1372        self,
1373        account_grant=None,
1374        meta=None,
1375        rate_limit=None,
1376    ):
1377        self.account_grant = account_grant if account_grant is not None else None
1378        '''
1379         The requested AccountGrant.
1380        '''
1381        self.meta = meta if meta is not None else None
1382        '''
1383         Reserved for future use.
1384        '''
1385        self.rate_limit = rate_limit if rate_limit is not None else None
1386        '''
1387         Rate limit information.
1388        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1397    def to_dict(self):
1398        return {
1399            'account_grant': self.account_grant,
1400            'meta': self.meta,
1401            'rate_limit': self.rate_limit,
1402        }
@classmethod
def from_dict(cls, d)
1404    @classmethod
1405    def from_dict(cls, d):
1406        return cls(
1407            account_grant=d.get('account_grant'),
1408            meta=d.get('meta'),
1409            rate_limit=d.get('rate_limit'),
1410        )
class AccountUpdateResponse:
1413class AccountUpdateResponse:
1414    '''
1415         AccountUpdateResponse returns the fields of a Account after it has been updated by
1416     a AccountUpdateRequest.
1417    '''
1418    __slots__ = [
1419        'account',
1420        'meta',
1421        'rate_limit',
1422    ]
1423
1424    def __init__(
1425        self,
1426        account=None,
1427        meta=None,
1428        rate_limit=None,
1429    ):
1430        self.account = account if account is not None else None
1431        '''
1432         The updated Account.
1433        '''
1434        self.meta = meta if meta is not None else None
1435        '''
1436         Reserved for future use.
1437        '''
1438        self.rate_limit = rate_limit if rate_limit is not None else None
1439        '''
1440         Rate limit information.
1441        '''
1442
1443    def __repr__(self):
1444        return '<sdm.AccountUpdateResponse ' + \
1445            'account: ' + repr(self.account) + ' ' +\
1446            'meta: ' + repr(self.meta) + ' ' +\
1447            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1448            '>'
1449
1450    def to_dict(self):
1451        return {
1452            'account': self.account,
1453            'meta': self.meta,
1454            'rate_limit': self.rate_limit,
1455        }
1456
1457    @classmethod
1458    def from_dict(cls, d):
1459        return cls(
1460            account=d.get('account'),
1461            meta=d.get('meta'),
1462            rate_limit=d.get('rate_limit'),
1463        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1424    def __init__(
1425        self,
1426        account=None,
1427        meta=None,
1428        rate_limit=None,
1429    ):
1430        self.account = account if account is not None else None
1431        '''
1432         The updated Account.
1433        '''
1434        self.meta = meta if meta is not None else None
1435        '''
1436         Reserved for future use.
1437        '''
1438        self.rate_limit = rate_limit if rate_limit is not None else None
1439        '''
1440         Rate limit information.
1441        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1450    def to_dict(self):
1451        return {
1452            'account': self.account,
1453            'meta': self.meta,
1454            'rate_limit': self.rate_limit,
1455        }
@classmethod
def from_dict(cls, d)
1457    @classmethod
1458    def from_dict(cls, d):
1459        return cls(
1460            account=d.get('account'),
1461            meta=d.get('meta'),
1462            rate_limit=d.get('rate_limit'),
1463        )
class AmazonEKS:
1466class AmazonEKS:
1467    __slots__ = [
1468        'access_key',
1469        'bind_interface',
1470        'certificate_authority',
1471        'cluster_name',
1472        'egress_filter',
1473        'endpoint',
1474        'healthcheck_namespace',
1475        'healthy',
1476        'id',
1477        'name',
1478        'region',
1479        'remote_identity_group_id',
1480        'remote_identity_healthcheck_username',
1481        'role_arn',
1482        'role_external_id',
1483        'secret_access_key',
1484        'secret_store_id',
1485        'tags',
1486    ]
1487
1488    def __init__(
1489        self,
1490        access_key=None,
1491        bind_interface=None,
1492        certificate_authority=None,
1493        cluster_name=None,
1494        egress_filter=None,
1495        endpoint=None,
1496        healthcheck_namespace=None,
1497        healthy=None,
1498        id=None,
1499        name=None,
1500        region=None,
1501        remote_identity_group_id=None,
1502        remote_identity_healthcheck_username=None,
1503        role_arn=None,
1504        role_external_id=None,
1505        secret_access_key=None,
1506        secret_store_id=None,
1507        tags=None,
1508    ):
1509        self.access_key = access_key if access_key is not None else ''
1510        self.bind_interface = bind_interface if bind_interface is not None else ''
1511        '''
1512         Bind interface
1513        '''
1514        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1515        self.cluster_name = cluster_name if cluster_name is not None else ''
1516        self.egress_filter = egress_filter if egress_filter is not None else ''
1517        '''
1518         A filter applied to the routing logic to pin datasource to nodes.
1519        '''
1520        self.endpoint = endpoint if endpoint is not None else ''
1521        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1522        '''
1523         The path used to check the health of your connection.  Defaults to `default`.
1524        '''
1525        self.healthy = healthy if healthy is not None else False
1526        '''
1527         True if the datasource is reachable and the credentials are valid.
1528        '''
1529        self.id = id if id is not None else ''
1530        '''
1531         Unique identifier of the Resource.
1532        '''
1533        self.name = name if name is not None else ''
1534        '''
1535         Unique human-readable name of the Resource.
1536        '''
1537        self.region = region if region is not None else ''
1538        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1539        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1540        self.role_arn = role_arn if role_arn is not None else ''
1541        self.role_external_id = role_external_id if role_external_id is not None else ''
1542        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1543        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1544        '''
1545         ID of the secret store containing credentials for this resource, if any.
1546        '''
1547        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1548        '''
1549         Tags is a map of key, value pairs.
1550        '''
1551
1552    def __repr__(self):
1553        return '<sdm.AmazonEKS ' + \
1554            'access_key: ' + repr(self.access_key) + ' ' +\
1555            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1556            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1557            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1558            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1559            'endpoint: ' + repr(self.endpoint) + ' ' +\
1560            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1561            'healthy: ' + repr(self.healthy) + ' ' +\
1562            'id: ' + repr(self.id) + ' ' +\
1563            'name: ' + repr(self.name) + ' ' +\
1564            'region: ' + repr(self.region) + ' ' +\
1565            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1566            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1567            'role_arn: ' + repr(self.role_arn) + ' ' +\
1568            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1569            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1570            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1571            'tags: ' + repr(self.tags) + ' ' +\
1572            '>'
1573
1574    def to_dict(self):
1575        return {
1576            'access_key': self.access_key,
1577            'bind_interface': self.bind_interface,
1578            'certificate_authority': self.certificate_authority,
1579            'cluster_name': self.cluster_name,
1580            'egress_filter': self.egress_filter,
1581            'endpoint': self.endpoint,
1582            'healthcheck_namespace': self.healthcheck_namespace,
1583            'healthy': self.healthy,
1584            'id': self.id,
1585            'name': self.name,
1586            'region': self.region,
1587            'remote_identity_group_id': self.remote_identity_group_id,
1588            'remote_identity_healthcheck_username':
1589            self.remote_identity_healthcheck_username,
1590            'role_arn': self.role_arn,
1591            'role_external_id': self.role_external_id,
1592            'secret_access_key': self.secret_access_key,
1593            'secret_store_id': self.secret_store_id,
1594            'tags': self.tags,
1595        }
1596
1597    @classmethod
1598    def from_dict(cls, d):
1599        return cls(
1600            access_key=d.get('access_key'),
1601            bind_interface=d.get('bind_interface'),
1602            certificate_authority=d.get('certificate_authority'),
1603            cluster_name=d.get('cluster_name'),
1604            egress_filter=d.get('egress_filter'),
1605            endpoint=d.get('endpoint'),
1606            healthcheck_namespace=d.get('healthcheck_namespace'),
1607            healthy=d.get('healthy'),
1608            id=d.get('id'),
1609            name=d.get('name'),
1610            region=d.get('region'),
1611            remote_identity_group_id=d.get('remote_identity_group_id'),
1612            remote_identity_healthcheck_username=d.get(
1613                'remote_identity_healthcheck_username'),
1614            role_arn=d.get('role_arn'),
1615            role_external_id=d.get('role_external_id'),
1616            secret_access_key=d.get('secret_access_key'),
1617            secret_store_id=d.get('secret_store_id'),
1618            tags=d.get('tags'),
1619        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1488    def __init__(
1489        self,
1490        access_key=None,
1491        bind_interface=None,
1492        certificate_authority=None,
1493        cluster_name=None,
1494        egress_filter=None,
1495        endpoint=None,
1496        healthcheck_namespace=None,
1497        healthy=None,
1498        id=None,
1499        name=None,
1500        region=None,
1501        remote_identity_group_id=None,
1502        remote_identity_healthcheck_username=None,
1503        role_arn=None,
1504        role_external_id=None,
1505        secret_access_key=None,
1506        secret_store_id=None,
1507        tags=None,
1508    ):
1509        self.access_key = access_key if access_key is not None else ''
1510        self.bind_interface = bind_interface if bind_interface is not None else ''
1511        '''
1512         Bind interface
1513        '''
1514        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1515        self.cluster_name = cluster_name if cluster_name is not None else ''
1516        self.egress_filter = egress_filter if egress_filter is not None else ''
1517        '''
1518         A filter applied to the routing logic to pin datasource to nodes.
1519        '''
1520        self.endpoint = endpoint if endpoint is not None else ''
1521        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1522        '''
1523         The path used to check the health of your connection.  Defaults to `default`.
1524        '''
1525        self.healthy = healthy if healthy is not None else False
1526        '''
1527         True if the datasource is reachable and the credentials are valid.
1528        '''
1529        self.id = id if id is not None else ''
1530        '''
1531         Unique identifier of the Resource.
1532        '''
1533        self.name = name if name is not None else ''
1534        '''
1535         Unique human-readable name of the Resource.
1536        '''
1537        self.region = region if region is not None else ''
1538        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1539        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1540        self.role_arn = role_arn if role_arn is not None else ''
1541        self.role_external_id = role_external_id if role_external_id is not None else ''
1542        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1543        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1544        '''
1545         ID of the secret store containing credentials for this resource, if any.
1546        '''
1547        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1548        '''
1549         Tags is a map of key, value pairs.
1550        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1574    def to_dict(self):
1575        return {
1576            'access_key': self.access_key,
1577            'bind_interface': self.bind_interface,
1578            'certificate_authority': self.certificate_authority,
1579            'cluster_name': self.cluster_name,
1580            'egress_filter': self.egress_filter,
1581            'endpoint': self.endpoint,
1582            'healthcheck_namespace': self.healthcheck_namespace,
1583            'healthy': self.healthy,
1584            'id': self.id,
1585            'name': self.name,
1586            'region': self.region,
1587            'remote_identity_group_id': self.remote_identity_group_id,
1588            'remote_identity_healthcheck_username':
1589            self.remote_identity_healthcheck_username,
1590            'role_arn': self.role_arn,
1591            'role_external_id': self.role_external_id,
1592            'secret_access_key': self.secret_access_key,
1593            'secret_store_id': self.secret_store_id,
1594            'tags': self.tags,
1595        }
@classmethod
def from_dict(cls, d)
1597    @classmethod
1598    def from_dict(cls, d):
1599        return cls(
1600            access_key=d.get('access_key'),
1601            bind_interface=d.get('bind_interface'),
1602            certificate_authority=d.get('certificate_authority'),
1603            cluster_name=d.get('cluster_name'),
1604            egress_filter=d.get('egress_filter'),
1605            endpoint=d.get('endpoint'),
1606            healthcheck_namespace=d.get('healthcheck_namespace'),
1607            healthy=d.get('healthy'),
1608            id=d.get('id'),
1609            name=d.get('name'),
1610            region=d.get('region'),
1611            remote_identity_group_id=d.get('remote_identity_group_id'),
1612            remote_identity_healthcheck_username=d.get(
1613                'remote_identity_healthcheck_username'),
1614            role_arn=d.get('role_arn'),
1615            role_external_id=d.get('role_external_id'),
1616            secret_access_key=d.get('secret_access_key'),
1617            secret_store_id=d.get('secret_store_id'),
1618            tags=d.get('tags'),
1619        )
class AmazonEKSUserImpersonation:
1622class AmazonEKSUserImpersonation:
1623    __slots__ = [
1624        'access_key',
1625        'bind_interface',
1626        'certificate_authority',
1627        'cluster_name',
1628        'egress_filter',
1629        'endpoint',
1630        'healthcheck_namespace',
1631        'healthy',
1632        'id',
1633        'name',
1634        'region',
1635        'role_arn',
1636        'role_external_id',
1637        'secret_access_key',
1638        'secret_store_id',
1639        'tags',
1640    ]
1641
1642    def __init__(
1643        self,
1644        access_key=None,
1645        bind_interface=None,
1646        certificate_authority=None,
1647        cluster_name=None,
1648        egress_filter=None,
1649        endpoint=None,
1650        healthcheck_namespace=None,
1651        healthy=None,
1652        id=None,
1653        name=None,
1654        region=None,
1655        role_arn=None,
1656        role_external_id=None,
1657        secret_access_key=None,
1658        secret_store_id=None,
1659        tags=None,
1660    ):
1661        self.access_key = access_key if access_key is not None else ''
1662        self.bind_interface = bind_interface if bind_interface is not None else ''
1663        '''
1664         Bind interface
1665        '''
1666        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1667        self.cluster_name = cluster_name if cluster_name is not None else ''
1668        self.egress_filter = egress_filter if egress_filter is not None else ''
1669        '''
1670         A filter applied to the routing logic to pin datasource to nodes.
1671        '''
1672        self.endpoint = endpoint if endpoint is not None else ''
1673        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1674        '''
1675         The path used to check the health of your connection.  Defaults to `default`.
1676        '''
1677        self.healthy = healthy if healthy is not None else False
1678        '''
1679         True if the datasource is reachable and the credentials are valid.
1680        '''
1681        self.id = id if id is not None else ''
1682        '''
1683         Unique identifier of the Resource.
1684        '''
1685        self.name = name if name is not None else ''
1686        '''
1687         Unique human-readable name of the Resource.
1688        '''
1689        self.region = region if region is not None else ''
1690        self.role_arn = role_arn if role_arn is not None else ''
1691        self.role_external_id = role_external_id if role_external_id is not None else ''
1692        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1693        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1694        '''
1695         ID of the secret store containing credentials for this resource, if any.
1696        '''
1697        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1698        '''
1699         Tags is a map of key, value pairs.
1700        '''
1701
1702    def __repr__(self):
1703        return '<sdm.AmazonEKSUserImpersonation ' + \
1704            'access_key: ' + repr(self.access_key) + ' ' +\
1705            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1706            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1707            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1708            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1709            'endpoint: ' + repr(self.endpoint) + ' ' +\
1710            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1711            'healthy: ' + repr(self.healthy) + ' ' +\
1712            'id: ' + repr(self.id) + ' ' +\
1713            'name: ' + repr(self.name) + ' ' +\
1714            'region: ' + repr(self.region) + ' ' +\
1715            'role_arn: ' + repr(self.role_arn) + ' ' +\
1716            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1717            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1718            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1719            'tags: ' + repr(self.tags) + ' ' +\
1720            '>'
1721
1722    def to_dict(self):
1723        return {
1724            'access_key': self.access_key,
1725            'bind_interface': self.bind_interface,
1726            'certificate_authority': self.certificate_authority,
1727            'cluster_name': self.cluster_name,
1728            'egress_filter': self.egress_filter,
1729            'endpoint': self.endpoint,
1730            'healthcheck_namespace': self.healthcheck_namespace,
1731            'healthy': self.healthy,
1732            'id': self.id,
1733            'name': self.name,
1734            'region': self.region,
1735            'role_arn': self.role_arn,
1736            'role_external_id': self.role_external_id,
1737            'secret_access_key': self.secret_access_key,
1738            'secret_store_id': self.secret_store_id,
1739            'tags': self.tags,
1740        }
1741
1742    @classmethod
1743    def from_dict(cls, d):
1744        return cls(
1745            access_key=d.get('access_key'),
1746            bind_interface=d.get('bind_interface'),
1747            certificate_authority=d.get('certificate_authority'),
1748            cluster_name=d.get('cluster_name'),
1749            egress_filter=d.get('egress_filter'),
1750            endpoint=d.get('endpoint'),
1751            healthcheck_namespace=d.get('healthcheck_namespace'),
1752            healthy=d.get('healthy'),
1753            id=d.get('id'),
1754            name=d.get('name'),
1755            region=d.get('region'),
1756            role_arn=d.get('role_arn'),
1757            role_external_id=d.get('role_external_id'),
1758            secret_access_key=d.get('secret_access_key'),
1759            secret_store_id=d.get('secret_store_id'),
1760            tags=d.get('tags'),
1761        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1642    def __init__(
1643        self,
1644        access_key=None,
1645        bind_interface=None,
1646        certificate_authority=None,
1647        cluster_name=None,
1648        egress_filter=None,
1649        endpoint=None,
1650        healthcheck_namespace=None,
1651        healthy=None,
1652        id=None,
1653        name=None,
1654        region=None,
1655        role_arn=None,
1656        role_external_id=None,
1657        secret_access_key=None,
1658        secret_store_id=None,
1659        tags=None,
1660    ):
1661        self.access_key = access_key if access_key is not None else ''
1662        self.bind_interface = bind_interface if bind_interface is not None else ''
1663        '''
1664         Bind interface
1665        '''
1666        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1667        self.cluster_name = cluster_name if cluster_name is not None else ''
1668        self.egress_filter = egress_filter if egress_filter is not None else ''
1669        '''
1670         A filter applied to the routing logic to pin datasource to nodes.
1671        '''
1672        self.endpoint = endpoint if endpoint is not None else ''
1673        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1674        '''
1675         The path used to check the health of your connection.  Defaults to `default`.
1676        '''
1677        self.healthy = healthy if healthy is not None else False
1678        '''
1679         True if the datasource is reachable and the credentials are valid.
1680        '''
1681        self.id = id if id is not None else ''
1682        '''
1683         Unique identifier of the Resource.
1684        '''
1685        self.name = name if name is not None else ''
1686        '''
1687         Unique human-readable name of the Resource.
1688        '''
1689        self.region = region if region is not None else ''
1690        self.role_arn = role_arn if role_arn is not None else ''
1691        self.role_external_id = role_external_id if role_external_id is not None else ''
1692        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1693        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1694        '''
1695         ID of the secret store containing credentials for this resource, if any.
1696        '''
1697        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1698        '''
1699         Tags is a map of key, value pairs.
1700        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1722    def to_dict(self):
1723        return {
1724            'access_key': self.access_key,
1725            'bind_interface': self.bind_interface,
1726            'certificate_authority': self.certificate_authority,
1727            'cluster_name': self.cluster_name,
1728            'egress_filter': self.egress_filter,
1729            'endpoint': self.endpoint,
1730            'healthcheck_namespace': self.healthcheck_namespace,
1731            'healthy': self.healthy,
1732            'id': self.id,
1733            'name': self.name,
1734            'region': self.region,
1735            'role_arn': self.role_arn,
1736            'role_external_id': self.role_external_id,
1737            'secret_access_key': self.secret_access_key,
1738            'secret_store_id': self.secret_store_id,
1739            'tags': self.tags,
1740        }
@classmethod
def from_dict(cls, d)
1742    @classmethod
1743    def from_dict(cls, d):
1744        return cls(
1745            access_key=d.get('access_key'),
1746            bind_interface=d.get('bind_interface'),
1747            certificate_authority=d.get('certificate_authority'),
1748            cluster_name=d.get('cluster_name'),
1749            egress_filter=d.get('egress_filter'),
1750            endpoint=d.get('endpoint'),
1751            healthcheck_namespace=d.get('healthcheck_namespace'),
1752            healthy=d.get('healthy'),
1753            id=d.get('id'),
1754            name=d.get('name'),
1755            region=d.get('region'),
1756            role_arn=d.get('role_arn'),
1757            role_external_id=d.get('role_external_id'),
1758            secret_access_key=d.get('secret_access_key'),
1759            secret_store_id=d.get('secret_store_id'),
1760            tags=d.get('tags'),
1761        )
class AmazonES:
1764class AmazonES:
1765    __slots__ = [
1766        'access_key',
1767        'bind_interface',
1768        'egress_filter',
1769        'endpoint',
1770        'healthy',
1771        'id',
1772        'name',
1773        'port_override',
1774        'region',
1775        'role_arn',
1776        'role_external_id',
1777        'secret_access_key',
1778        'secret_store_id',
1779        'tags',
1780    ]
1781
1782    def __init__(
1783        self,
1784        access_key=None,
1785        bind_interface=None,
1786        egress_filter=None,
1787        endpoint=None,
1788        healthy=None,
1789        id=None,
1790        name=None,
1791        port_override=None,
1792        region=None,
1793        role_arn=None,
1794        role_external_id=None,
1795        secret_access_key=None,
1796        secret_store_id=None,
1797        tags=None,
1798    ):
1799        self.access_key = access_key if access_key is not None else ''
1800        self.bind_interface = bind_interface if bind_interface is not None else ''
1801        '''
1802         Bind interface
1803        '''
1804        self.egress_filter = egress_filter if egress_filter is not None else ''
1805        '''
1806         A filter applied to the routing logic to pin datasource to nodes.
1807        '''
1808        self.endpoint = endpoint if endpoint is not None else ''
1809        self.healthy = healthy if healthy is not None else False
1810        '''
1811         True if the datasource is reachable and the credentials are valid.
1812        '''
1813        self.id = id if id is not None else ''
1814        '''
1815         Unique identifier of the Resource.
1816        '''
1817        self.name = name if name is not None else ''
1818        '''
1819         Unique human-readable name of the Resource.
1820        '''
1821        self.port_override = port_override if port_override is not None else 0
1822        self.region = region if region is not None else ''
1823        self.role_arn = role_arn if role_arn is not None else ''
1824        self.role_external_id = role_external_id if role_external_id is not None else ''
1825        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1826        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1827        '''
1828         ID of the secret store containing credentials for this resource, if any.
1829        '''
1830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1831        '''
1832         Tags is a map of key, value pairs.
1833        '''
1834
1835    def __repr__(self):
1836        return '<sdm.AmazonES ' + \
1837            'access_key: ' + repr(self.access_key) + ' ' +\
1838            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1839            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1840            'endpoint: ' + repr(self.endpoint) + ' ' +\
1841            'healthy: ' + repr(self.healthy) + ' ' +\
1842            'id: ' + repr(self.id) + ' ' +\
1843            'name: ' + repr(self.name) + ' ' +\
1844            'port_override: ' + repr(self.port_override) + ' ' +\
1845            'region: ' + repr(self.region) + ' ' +\
1846            'role_arn: ' + repr(self.role_arn) + ' ' +\
1847            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1848            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1849            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1850            'tags: ' + repr(self.tags) + ' ' +\
1851            '>'
1852
1853    def to_dict(self):
1854        return {
1855            'access_key': self.access_key,
1856            'bind_interface': self.bind_interface,
1857            'egress_filter': self.egress_filter,
1858            'endpoint': self.endpoint,
1859            'healthy': self.healthy,
1860            'id': self.id,
1861            'name': self.name,
1862            'port_override': self.port_override,
1863            'region': self.region,
1864            'role_arn': self.role_arn,
1865            'role_external_id': self.role_external_id,
1866            'secret_access_key': self.secret_access_key,
1867            'secret_store_id': self.secret_store_id,
1868            'tags': self.tags,
1869        }
1870
1871    @classmethod
1872    def from_dict(cls, d):
1873        return cls(
1874            access_key=d.get('access_key'),
1875            bind_interface=d.get('bind_interface'),
1876            egress_filter=d.get('egress_filter'),
1877            endpoint=d.get('endpoint'),
1878            healthy=d.get('healthy'),
1879            id=d.get('id'),
1880            name=d.get('name'),
1881            port_override=d.get('port_override'),
1882            region=d.get('region'),
1883            role_arn=d.get('role_arn'),
1884            role_external_id=d.get('role_external_id'),
1885            secret_access_key=d.get('secret_access_key'),
1886            secret_store_id=d.get('secret_store_id'),
1887            tags=d.get('tags'),
1888        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1782    def __init__(
1783        self,
1784        access_key=None,
1785        bind_interface=None,
1786        egress_filter=None,
1787        endpoint=None,
1788        healthy=None,
1789        id=None,
1790        name=None,
1791        port_override=None,
1792        region=None,
1793        role_arn=None,
1794        role_external_id=None,
1795        secret_access_key=None,
1796        secret_store_id=None,
1797        tags=None,
1798    ):
1799        self.access_key = access_key if access_key is not None else ''
1800        self.bind_interface = bind_interface if bind_interface is not None else ''
1801        '''
1802         Bind interface
1803        '''
1804        self.egress_filter = egress_filter if egress_filter is not None else ''
1805        '''
1806         A filter applied to the routing logic to pin datasource to nodes.
1807        '''
1808        self.endpoint = endpoint if endpoint is not None else ''
1809        self.healthy = healthy if healthy is not None else False
1810        '''
1811         True if the datasource is reachable and the credentials are valid.
1812        '''
1813        self.id = id if id is not None else ''
1814        '''
1815         Unique identifier of the Resource.
1816        '''
1817        self.name = name if name is not None else ''
1818        '''
1819         Unique human-readable name of the Resource.
1820        '''
1821        self.port_override = port_override if port_override is not None else 0
1822        self.region = region if region is not None else ''
1823        self.role_arn = role_arn if role_arn is not None else ''
1824        self.role_external_id = role_external_id if role_external_id is not None else ''
1825        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1826        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1827        '''
1828         ID of the secret store containing credentials for this resource, if any.
1829        '''
1830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1831        '''
1832         Tags is a map of key, value pairs.
1833        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1853    def to_dict(self):
1854        return {
1855            'access_key': self.access_key,
1856            'bind_interface': self.bind_interface,
1857            'egress_filter': self.egress_filter,
1858            'endpoint': self.endpoint,
1859            'healthy': self.healthy,
1860            'id': self.id,
1861            'name': self.name,
1862            'port_override': self.port_override,
1863            'region': self.region,
1864            'role_arn': self.role_arn,
1865            'role_external_id': self.role_external_id,
1866            'secret_access_key': self.secret_access_key,
1867            'secret_store_id': self.secret_store_id,
1868            'tags': self.tags,
1869        }
@classmethod
def from_dict(cls, d)
1871    @classmethod
1872    def from_dict(cls, d):
1873        return cls(
1874            access_key=d.get('access_key'),
1875            bind_interface=d.get('bind_interface'),
1876            egress_filter=d.get('egress_filter'),
1877            endpoint=d.get('endpoint'),
1878            healthy=d.get('healthy'),
1879            id=d.get('id'),
1880            name=d.get('name'),
1881            port_override=d.get('port_override'),
1882            region=d.get('region'),
1883            role_arn=d.get('role_arn'),
1884            role_external_id=d.get('role_external_id'),
1885            secret_access_key=d.get('secret_access_key'),
1886            secret_store_id=d.get('secret_store_id'),
1887            tags=d.get('tags'),
1888        )
class AmazonMQAMQP091:
1891class AmazonMQAMQP091:
1892    __slots__ = [
1893        'bind_interface',
1894        'egress_filter',
1895        'healthy',
1896        'hostname',
1897        'id',
1898        'name',
1899        'password',
1900        'port',
1901        'port_override',
1902        'secret_store_id',
1903        'tags',
1904        'tls_required',
1905        'username',
1906    ]
1907
1908    def __init__(
1909        self,
1910        bind_interface=None,
1911        egress_filter=None,
1912        healthy=None,
1913        hostname=None,
1914        id=None,
1915        name=None,
1916        password=None,
1917        port=None,
1918        port_override=None,
1919        secret_store_id=None,
1920        tags=None,
1921        tls_required=None,
1922        username=None,
1923    ):
1924        self.bind_interface = bind_interface if bind_interface is not None else ''
1925        '''
1926         Bind interface
1927        '''
1928        self.egress_filter = egress_filter if egress_filter is not None else ''
1929        '''
1930         A filter applied to the routing logic to pin datasource to nodes.
1931        '''
1932        self.healthy = healthy if healthy is not None else False
1933        '''
1934         True if the datasource is reachable and the credentials are valid.
1935        '''
1936        self.hostname = hostname if hostname is not None else ''
1937        self.id = id if id is not None else ''
1938        '''
1939         Unique identifier of the Resource.
1940        '''
1941        self.name = name if name is not None else ''
1942        '''
1943         Unique human-readable name of the Resource.
1944        '''
1945        self.password = password if password is not None else ''
1946        self.port = port if port is not None else 0
1947        self.port_override = port_override if port_override is not None else 0
1948        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1949        '''
1950         ID of the secret store containing credentials for this resource, if any.
1951        '''
1952        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1953        '''
1954         Tags is a map of key, value pairs.
1955        '''
1956        self.tls_required = tls_required if tls_required is not None else False
1957        self.username = username if username is not None else ''
1958
1959    def __repr__(self):
1960        return '<sdm.AmazonMQAMQP091 ' + \
1961            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1962            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1963            'healthy: ' + repr(self.healthy) + ' ' +\
1964            'hostname: ' + repr(self.hostname) + ' ' +\
1965            'id: ' + repr(self.id) + ' ' +\
1966            'name: ' + repr(self.name) + ' ' +\
1967            'password: ' + repr(self.password) + ' ' +\
1968            'port: ' + repr(self.port) + ' ' +\
1969            'port_override: ' + repr(self.port_override) + ' ' +\
1970            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1971            'tags: ' + repr(self.tags) + ' ' +\
1972            'tls_required: ' + repr(self.tls_required) + ' ' +\
1973            'username: ' + repr(self.username) + ' ' +\
1974            '>'
1975
1976    def to_dict(self):
1977        return {
1978            'bind_interface': self.bind_interface,
1979            'egress_filter': self.egress_filter,
1980            'healthy': self.healthy,
1981            'hostname': self.hostname,
1982            'id': self.id,
1983            'name': self.name,
1984            'password': self.password,
1985            'port': self.port,
1986            'port_override': self.port_override,
1987            'secret_store_id': self.secret_store_id,
1988            'tags': self.tags,
1989            'tls_required': self.tls_required,
1990            'username': self.username,
1991        }
1992
1993    @classmethod
1994    def from_dict(cls, d):
1995        return cls(
1996            bind_interface=d.get('bind_interface'),
1997            egress_filter=d.get('egress_filter'),
1998            healthy=d.get('healthy'),
1999            hostname=d.get('hostname'),
2000            id=d.get('id'),
2001            name=d.get('name'),
2002            password=d.get('password'),
2003            port=d.get('port'),
2004            port_override=d.get('port_override'),
2005            secret_store_id=d.get('secret_store_id'),
2006            tags=d.get('tags'),
2007            tls_required=d.get('tls_required'),
2008            username=d.get('username'),
2009        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
1908    def __init__(
1909        self,
1910        bind_interface=None,
1911        egress_filter=None,
1912        healthy=None,
1913        hostname=None,
1914        id=None,
1915        name=None,
1916        password=None,
1917        port=None,
1918        port_override=None,
1919        secret_store_id=None,
1920        tags=None,
1921        tls_required=None,
1922        username=None,
1923    ):
1924        self.bind_interface = bind_interface if bind_interface is not None else ''
1925        '''
1926         Bind interface
1927        '''
1928        self.egress_filter = egress_filter if egress_filter is not None else ''
1929        '''
1930         A filter applied to the routing logic to pin datasource to nodes.
1931        '''
1932        self.healthy = healthy if healthy is not None else False
1933        '''
1934         True if the datasource is reachable and the credentials are valid.
1935        '''
1936        self.hostname = hostname if hostname is not None else ''
1937        self.id = id if id is not None else ''
1938        '''
1939         Unique identifier of the Resource.
1940        '''
1941        self.name = name if name is not None else ''
1942        '''
1943         Unique human-readable name of the Resource.
1944        '''
1945        self.password = password if password is not None else ''
1946        self.port = port if port is not None else 0
1947        self.port_override = port_override if port_override is not None else 0
1948        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1949        '''
1950         ID of the secret store containing credentials for this resource, if any.
1951        '''
1952        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1953        '''
1954         Tags is a map of key, value pairs.
1955        '''
1956        self.tls_required = tls_required if tls_required is not None else False
1957        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
1976    def to_dict(self):
1977        return {
1978            'bind_interface': self.bind_interface,
1979            'egress_filter': self.egress_filter,
1980            'healthy': self.healthy,
1981            'hostname': self.hostname,
1982            'id': self.id,
1983            'name': self.name,
1984            'password': self.password,
1985            'port': self.port,
1986            'port_override': self.port_override,
1987            'secret_store_id': self.secret_store_id,
1988            'tags': self.tags,
1989            'tls_required': self.tls_required,
1990            'username': self.username,
1991        }
@classmethod
def from_dict(cls, d)
1993    @classmethod
1994    def from_dict(cls, d):
1995        return cls(
1996            bind_interface=d.get('bind_interface'),
1997            egress_filter=d.get('egress_filter'),
1998            healthy=d.get('healthy'),
1999            hostname=d.get('hostname'),
2000            id=d.get('id'),
2001            name=d.get('name'),
2002            password=d.get('password'),
2003            port=d.get('port'),
2004            port_override=d.get('port_override'),
2005            secret_store_id=d.get('secret_store_id'),
2006            tags=d.get('tags'),
2007            tls_required=d.get('tls_required'),
2008            username=d.get('username'),
2009        )
class Athena:
2012class Athena:
2013    __slots__ = [
2014        'access_key',
2015        'bind_interface',
2016        'egress_filter',
2017        'healthy',
2018        'id',
2019        'name',
2020        'output',
2021        'port_override',
2022        'region',
2023        'role_arn',
2024        'role_external_id',
2025        'secret_access_key',
2026        'secret_store_id',
2027        'tags',
2028    ]
2029
2030    def __init__(
2031        self,
2032        access_key=None,
2033        bind_interface=None,
2034        egress_filter=None,
2035        healthy=None,
2036        id=None,
2037        name=None,
2038        output=None,
2039        port_override=None,
2040        region=None,
2041        role_arn=None,
2042        role_external_id=None,
2043        secret_access_key=None,
2044        secret_store_id=None,
2045        tags=None,
2046    ):
2047        self.access_key = access_key if access_key is not None else ''
2048        self.bind_interface = bind_interface if bind_interface is not None else ''
2049        '''
2050         Bind interface
2051        '''
2052        self.egress_filter = egress_filter if egress_filter is not None else ''
2053        '''
2054         A filter applied to the routing logic to pin datasource to nodes.
2055        '''
2056        self.healthy = healthy if healthy is not None else False
2057        '''
2058         True if the datasource is reachable and the credentials are valid.
2059        '''
2060        self.id = id if id is not None else ''
2061        '''
2062         Unique identifier of the Resource.
2063        '''
2064        self.name = name if name is not None else ''
2065        '''
2066         Unique human-readable name of the Resource.
2067        '''
2068        self.output = output if output is not None else ''
2069        self.port_override = port_override if port_override is not None else 0
2070        self.region = region if region is not None else ''
2071        self.role_arn = role_arn if role_arn is not None else ''
2072        self.role_external_id = role_external_id if role_external_id is not None else ''
2073        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2075        '''
2076         ID of the secret store containing credentials for this resource, if any.
2077        '''
2078        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2079        '''
2080         Tags is a map of key, value pairs.
2081        '''
2082
2083    def __repr__(self):
2084        return '<sdm.Athena ' + \
2085            'access_key: ' + repr(self.access_key) + ' ' +\
2086            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2087            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2088            'healthy: ' + repr(self.healthy) + ' ' +\
2089            'id: ' + repr(self.id) + ' ' +\
2090            'name: ' + repr(self.name) + ' ' +\
2091            'output: ' + repr(self.output) + ' ' +\
2092            'port_override: ' + repr(self.port_override) + ' ' +\
2093            'region: ' + repr(self.region) + ' ' +\
2094            'role_arn: ' + repr(self.role_arn) + ' ' +\
2095            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2096            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2097            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2098            'tags: ' + repr(self.tags) + ' ' +\
2099            '>'
2100
2101    def to_dict(self):
2102        return {
2103            'access_key': self.access_key,
2104            'bind_interface': self.bind_interface,
2105            'egress_filter': self.egress_filter,
2106            'healthy': self.healthy,
2107            'id': self.id,
2108            'name': self.name,
2109            'output': self.output,
2110            'port_override': self.port_override,
2111            'region': self.region,
2112            'role_arn': self.role_arn,
2113            'role_external_id': self.role_external_id,
2114            'secret_access_key': self.secret_access_key,
2115            'secret_store_id': self.secret_store_id,
2116            'tags': self.tags,
2117        }
2118
2119    @classmethod
2120    def from_dict(cls, d):
2121        return cls(
2122            access_key=d.get('access_key'),
2123            bind_interface=d.get('bind_interface'),
2124            egress_filter=d.get('egress_filter'),
2125            healthy=d.get('healthy'),
2126            id=d.get('id'),
2127            name=d.get('name'),
2128            output=d.get('output'),
2129            port_override=d.get('port_override'),
2130            region=d.get('region'),
2131            role_arn=d.get('role_arn'),
2132            role_external_id=d.get('role_external_id'),
2133            secret_access_key=d.get('secret_access_key'),
2134            secret_store_id=d.get('secret_store_id'),
2135            tags=d.get('tags'),
2136        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2030    def __init__(
2031        self,
2032        access_key=None,
2033        bind_interface=None,
2034        egress_filter=None,
2035        healthy=None,
2036        id=None,
2037        name=None,
2038        output=None,
2039        port_override=None,
2040        region=None,
2041        role_arn=None,
2042        role_external_id=None,
2043        secret_access_key=None,
2044        secret_store_id=None,
2045        tags=None,
2046    ):
2047        self.access_key = access_key if access_key is not None else ''
2048        self.bind_interface = bind_interface if bind_interface is not None else ''
2049        '''
2050         Bind interface
2051        '''
2052        self.egress_filter = egress_filter if egress_filter is not None else ''
2053        '''
2054         A filter applied to the routing logic to pin datasource to nodes.
2055        '''
2056        self.healthy = healthy if healthy is not None else False
2057        '''
2058         True if the datasource is reachable and the credentials are valid.
2059        '''
2060        self.id = id if id is not None else ''
2061        '''
2062         Unique identifier of the Resource.
2063        '''
2064        self.name = name if name is not None else ''
2065        '''
2066         Unique human-readable name of the Resource.
2067        '''
2068        self.output = output if output is not None else ''
2069        self.port_override = port_override if port_override is not None else 0
2070        self.region = region if region is not None else ''
2071        self.role_arn = role_arn if role_arn is not None else ''
2072        self.role_external_id = role_external_id if role_external_id is not None else ''
2073        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2075        '''
2076         ID of the secret store containing credentials for this resource, if any.
2077        '''
2078        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2079        '''
2080         Tags is a map of key, value pairs.
2081        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2101    def to_dict(self):
2102        return {
2103            'access_key': self.access_key,
2104            'bind_interface': self.bind_interface,
2105            'egress_filter': self.egress_filter,
2106            'healthy': self.healthy,
2107            'id': self.id,
2108            'name': self.name,
2109            'output': self.output,
2110            'port_override': self.port_override,
2111            'region': self.region,
2112            'role_arn': self.role_arn,
2113            'role_external_id': self.role_external_id,
2114            'secret_access_key': self.secret_access_key,
2115            'secret_store_id': self.secret_store_id,
2116            'tags': self.tags,
2117        }
@classmethod
def from_dict(cls, d)
2119    @classmethod
2120    def from_dict(cls, d):
2121        return cls(
2122            access_key=d.get('access_key'),
2123            bind_interface=d.get('bind_interface'),
2124            egress_filter=d.get('egress_filter'),
2125            healthy=d.get('healthy'),
2126            id=d.get('id'),
2127            name=d.get('name'),
2128            output=d.get('output'),
2129            port_override=d.get('port_override'),
2130            region=d.get('region'),
2131            role_arn=d.get('role_arn'),
2132            role_external_id=d.get('role_external_id'),
2133            secret_access_key=d.get('secret_access_key'),
2134            secret_store_id=d.get('secret_store_id'),
2135            tags=d.get('tags'),
2136        )
class AuroraMysql:
2139class AuroraMysql:
2140    __slots__ = [
2141        'bind_interface',
2142        'database',
2143        'egress_filter',
2144        'healthy',
2145        'hostname',
2146        'id',
2147        'name',
2148        'password',
2149        'port',
2150        'port_override',
2151        'secret_store_id',
2152        'tags',
2153        'username',
2154    ]
2155
2156    def __init__(
2157        self,
2158        bind_interface=None,
2159        database=None,
2160        egress_filter=None,
2161        healthy=None,
2162        hostname=None,
2163        id=None,
2164        name=None,
2165        password=None,
2166        port=None,
2167        port_override=None,
2168        secret_store_id=None,
2169        tags=None,
2170        username=None,
2171    ):
2172        self.bind_interface = bind_interface if bind_interface is not None else ''
2173        '''
2174         Bind interface
2175        '''
2176        self.database = database if database is not None else ''
2177        self.egress_filter = egress_filter if egress_filter is not None else ''
2178        '''
2179         A filter applied to the routing logic to pin datasource to nodes.
2180        '''
2181        self.healthy = healthy if healthy is not None else False
2182        '''
2183         True if the datasource is reachable and the credentials are valid.
2184        '''
2185        self.hostname = hostname if hostname is not None else ''
2186        self.id = id if id is not None else ''
2187        '''
2188         Unique identifier of the Resource.
2189        '''
2190        self.name = name if name is not None else ''
2191        '''
2192         Unique human-readable name of the Resource.
2193        '''
2194        self.password = password if password is not None else ''
2195        self.port = port if port is not None else 0
2196        self.port_override = port_override if port_override is not None else 0
2197        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2198        '''
2199         ID of the secret store containing credentials for this resource, if any.
2200        '''
2201        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2202        '''
2203         Tags is a map of key, value pairs.
2204        '''
2205        self.username = username if username is not None else ''
2206
2207    def __repr__(self):
2208        return '<sdm.AuroraMysql ' + \
2209            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2210            'database: ' + repr(self.database) + ' ' +\
2211            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2212            'healthy: ' + repr(self.healthy) + ' ' +\
2213            'hostname: ' + repr(self.hostname) + ' ' +\
2214            'id: ' + repr(self.id) + ' ' +\
2215            'name: ' + repr(self.name) + ' ' +\
2216            'password: ' + repr(self.password) + ' ' +\
2217            'port: ' + repr(self.port) + ' ' +\
2218            'port_override: ' + repr(self.port_override) + ' ' +\
2219            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2220            'tags: ' + repr(self.tags) + ' ' +\
2221            'username: ' + repr(self.username) + ' ' +\
2222            '>'
2223
2224    def to_dict(self):
2225        return {
2226            'bind_interface': self.bind_interface,
2227            'database': self.database,
2228            'egress_filter': self.egress_filter,
2229            'healthy': self.healthy,
2230            'hostname': self.hostname,
2231            'id': self.id,
2232            'name': self.name,
2233            'password': self.password,
2234            'port': self.port,
2235            'port_override': self.port_override,
2236            'secret_store_id': self.secret_store_id,
2237            'tags': self.tags,
2238            'username': self.username,
2239        }
2240
2241    @classmethod
2242    def from_dict(cls, d):
2243        return cls(
2244            bind_interface=d.get('bind_interface'),
2245            database=d.get('database'),
2246            egress_filter=d.get('egress_filter'),
2247            healthy=d.get('healthy'),
2248            hostname=d.get('hostname'),
2249            id=d.get('id'),
2250            name=d.get('name'),
2251            password=d.get('password'),
2252            port=d.get('port'),
2253            port_override=d.get('port_override'),
2254            secret_store_id=d.get('secret_store_id'),
2255            tags=d.get('tags'),
2256            username=d.get('username'),
2257        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2156    def __init__(
2157        self,
2158        bind_interface=None,
2159        database=None,
2160        egress_filter=None,
2161        healthy=None,
2162        hostname=None,
2163        id=None,
2164        name=None,
2165        password=None,
2166        port=None,
2167        port_override=None,
2168        secret_store_id=None,
2169        tags=None,
2170        username=None,
2171    ):
2172        self.bind_interface = bind_interface if bind_interface is not None else ''
2173        '''
2174         Bind interface
2175        '''
2176        self.database = database if database is not None else ''
2177        self.egress_filter = egress_filter if egress_filter is not None else ''
2178        '''
2179         A filter applied to the routing logic to pin datasource to nodes.
2180        '''
2181        self.healthy = healthy if healthy is not None else False
2182        '''
2183         True if the datasource is reachable and the credentials are valid.
2184        '''
2185        self.hostname = hostname if hostname is not None else ''
2186        self.id = id if id is not None else ''
2187        '''
2188         Unique identifier of the Resource.
2189        '''
2190        self.name = name if name is not None else ''
2191        '''
2192         Unique human-readable name of the Resource.
2193        '''
2194        self.password = password if password is not None else ''
2195        self.port = port if port is not None else 0
2196        self.port_override = port_override if port_override is not None else 0
2197        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2198        '''
2199         ID of the secret store containing credentials for this resource, if any.
2200        '''
2201        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2202        '''
2203         Tags is a map of key, value pairs.
2204        '''
2205        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2224    def to_dict(self):
2225        return {
2226            'bind_interface': self.bind_interface,
2227            'database': self.database,
2228            'egress_filter': self.egress_filter,
2229            'healthy': self.healthy,
2230            'hostname': self.hostname,
2231            'id': self.id,
2232            'name': self.name,
2233            'password': self.password,
2234            'port': self.port,
2235            'port_override': self.port_override,
2236            'secret_store_id': self.secret_store_id,
2237            'tags': self.tags,
2238            'username': self.username,
2239        }
@classmethod
def from_dict(cls, d)
2241    @classmethod
2242    def from_dict(cls, d):
2243        return cls(
2244            bind_interface=d.get('bind_interface'),
2245            database=d.get('database'),
2246            egress_filter=d.get('egress_filter'),
2247            healthy=d.get('healthy'),
2248            hostname=d.get('hostname'),
2249            id=d.get('id'),
2250            name=d.get('name'),
2251            password=d.get('password'),
2252            port=d.get('port'),
2253            port_override=d.get('port_override'),
2254            secret_store_id=d.get('secret_store_id'),
2255            tags=d.get('tags'),
2256            username=d.get('username'),
2257        )
class AuroraPostgres:
2260class AuroraPostgres:
2261    __slots__ = [
2262        'bind_interface',
2263        'database',
2264        'egress_filter',
2265        'healthy',
2266        'hostname',
2267        'id',
2268        'name',
2269        'override_database',
2270        'password',
2271        'port',
2272        'port_override',
2273        'secret_store_id',
2274        'tags',
2275        'username',
2276    ]
2277
2278    def __init__(
2279        self,
2280        bind_interface=None,
2281        database=None,
2282        egress_filter=None,
2283        healthy=None,
2284        hostname=None,
2285        id=None,
2286        name=None,
2287        override_database=None,
2288        password=None,
2289        port=None,
2290        port_override=None,
2291        secret_store_id=None,
2292        tags=None,
2293        username=None,
2294    ):
2295        self.bind_interface = bind_interface if bind_interface is not None else ''
2296        '''
2297         Bind interface
2298        '''
2299        self.database = database if database is not None else ''
2300        self.egress_filter = egress_filter if egress_filter is not None else ''
2301        '''
2302         A filter applied to the routing logic to pin datasource to nodes.
2303        '''
2304        self.healthy = healthy if healthy is not None else False
2305        '''
2306         True if the datasource is reachable and the credentials are valid.
2307        '''
2308        self.hostname = hostname if hostname is not None else ''
2309        self.id = id if id is not None else ''
2310        '''
2311         Unique identifier of the Resource.
2312        '''
2313        self.name = name if name is not None else ''
2314        '''
2315         Unique human-readable name of the Resource.
2316        '''
2317        self.override_database = override_database if override_database is not None else False
2318        self.password = password if password is not None else ''
2319        self.port = port if port is not None else 0
2320        self.port_override = port_override if port_override is not None else 0
2321        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2322        '''
2323         ID of the secret store containing credentials for this resource, if any.
2324        '''
2325        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2326        '''
2327         Tags is a map of key, value pairs.
2328        '''
2329        self.username = username if username is not None else ''
2330
2331    def __repr__(self):
2332        return '<sdm.AuroraPostgres ' + \
2333            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2334            'database: ' + repr(self.database) + ' ' +\
2335            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2336            'healthy: ' + repr(self.healthy) + ' ' +\
2337            'hostname: ' + repr(self.hostname) + ' ' +\
2338            'id: ' + repr(self.id) + ' ' +\
2339            'name: ' + repr(self.name) + ' ' +\
2340            'override_database: ' + repr(self.override_database) + ' ' +\
2341            'password: ' + repr(self.password) + ' ' +\
2342            'port: ' + repr(self.port) + ' ' +\
2343            'port_override: ' + repr(self.port_override) + ' ' +\
2344            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2345            'tags: ' + repr(self.tags) + ' ' +\
2346            'username: ' + repr(self.username) + ' ' +\
2347            '>'
2348
2349    def to_dict(self):
2350        return {
2351            'bind_interface': self.bind_interface,
2352            'database': self.database,
2353            'egress_filter': self.egress_filter,
2354            'healthy': self.healthy,
2355            'hostname': self.hostname,
2356            'id': self.id,
2357            'name': self.name,
2358            'override_database': self.override_database,
2359            'password': self.password,
2360            'port': self.port,
2361            'port_override': self.port_override,
2362            'secret_store_id': self.secret_store_id,
2363            'tags': self.tags,
2364            'username': self.username,
2365        }
2366
2367    @classmethod
2368    def from_dict(cls, d):
2369        return cls(
2370            bind_interface=d.get('bind_interface'),
2371            database=d.get('database'),
2372            egress_filter=d.get('egress_filter'),
2373            healthy=d.get('healthy'),
2374            hostname=d.get('hostname'),
2375            id=d.get('id'),
2376            name=d.get('name'),
2377            override_database=d.get('override_database'),
2378            password=d.get('password'),
2379            port=d.get('port'),
2380            port_override=d.get('port_override'),
2381            secret_store_id=d.get('secret_store_id'),
2382            tags=d.get('tags'),
2383            username=d.get('username'),
2384        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2278    def __init__(
2279        self,
2280        bind_interface=None,
2281        database=None,
2282        egress_filter=None,
2283        healthy=None,
2284        hostname=None,
2285        id=None,
2286        name=None,
2287        override_database=None,
2288        password=None,
2289        port=None,
2290        port_override=None,
2291        secret_store_id=None,
2292        tags=None,
2293        username=None,
2294    ):
2295        self.bind_interface = bind_interface if bind_interface is not None else ''
2296        '''
2297         Bind interface
2298        '''
2299        self.database = database if database is not None else ''
2300        self.egress_filter = egress_filter if egress_filter is not None else ''
2301        '''
2302         A filter applied to the routing logic to pin datasource to nodes.
2303        '''
2304        self.healthy = healthy if healthy is not None else False
2305        '''
2306         True if the datasource is reachable and the credentials are valid.
2307        '''
2308        self.hostname = hostname if hostname is not None else ''
2309        self.id = id if id is not None else ''
2310        '''
2311         Unique identifier of the Resource.
2312        '''
2313        self.name = name if name is not None else ''
2314        '''
2315         Unique human-readable name of the Resource.
2316        '''
2317        self.override_database = override_database if override_database is not None else False
2318        self.password = password if password is not None else ''
2319        self.port = port if port is not None else 0
2320        self.port_override = port_override if port_override is not None else 0
2321        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2322        '''
2323         ID of the secret store containing credentials for this resource, if any.
2324        '''
2325        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2326        '''
2327         Tags is a map of key, value pairs.
2328        '''
2329        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2349    def to_dict(self):
2350        return {
2351            'bind_interface': self.bind_interface,
2352            'database': self.database,
2353            'egress_filter': self.egress_filter,
2354            'healthy': self.healthy,
2355            'hostname': self.hostname,
2356            'id': self.id,
2357            'name': self.name,
2358            'override_database': self.override_database,
2359            'password': self.password,
2360            'port': self.port,
2361            'port_override': self.port_override,
2362            'secret_store_id': self.secret_store_id,
2363            'tags': self.tags,
2364            'username': self.username,
2365        }
@classmethod
def from_dict(cls, d)
2367    @classmethod
2368    def from_dict(cls, d):
2369        return cls(
2370            bind_interface=d.get('bind_interface'),
2371            database=d.get('database'),
2372            egress_filter=d.get('egress_filter'),
2373            healthy=d.get('healthy'),
2374            hostname=d.get('hostname'),
2375            id=d.get('id'),
2376            name=d.get('name'),
2377            override_database=d.get('override_database'),
2378            password=d.get('password'),
2379            port=d.get('port'),
2380            port_override=d.get('port_override'),
2381            secret_store_id=d.get('secret_store_id'),
2382            tags=d.get('tags'),
2383            username=d.get('username'),
2384        )
class Azure:
2387class Azure:
2388    __slots__ = [
2389        'app_id',
2390        'bind_interface',
2391        'egress_filter',
2392        'healthy',
2393        'id',
2394        'name',
2395        'password',
2396        'secret_store_id',
2397        'tags',
2398        'tenant_id',
2399    ]
2400
2401    def __init__(
2402        self,
2403        app_id=None,
2404        bind_interface=None,
2405        egress_filter=None,
2406        healthy=None,
2407        id=None,
2408        name=None,
2409        password=None,
2410        secret_store_id=None,
2411        tags=None,
2412        tenant_id=None,
2413    ):
2414        self.app_id = app_id if app_id is not None else ''
2415        self.bind_interface = bind_interface if bind_interface is not None else ''
2416        '''
2417         Bind interface
2418        '''
2419        self.egress_filter = egress_filter if egress_filter is not None else ''
2420        '''
2421         A filter applied to the routing logic to pin datasource to nodes.
2422        '''
2423        self.healthy = healthy if healthy is not None else False
2424        '''
2425         True if the datasource is reachable and the credentials are valid.
2426        '''
2427        self.id = id if id is not None else ''
2428        '''
2429         Unique identifier of the Resource.
2430        '''
2431        self.name = name if name is not None else ''
2432        '''
2433         Unique human-readable name of the Resource.
2434        '''
2435        self.password = password if password is not None else ''
2436        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2437        '''
2438         ID of the secret store containing credentials for this resource, if any.
2439        '''
2440        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2441        '''
2442         Tags is a map of key, value pairs.
2443        '''
2444        self.tenant_id = tenant_id if tenant_id is not None else ''
2445
2446    def __repr__(self):
2447        return '<sdm.Azure ' + \
2448            'app_id: ' + repr(self.app_id) + ' ' +\
2449            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2450            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2451            'healthy: ' + repr(self.healthy) + ' ' +\
2452            'id: ' + repr(self.id) + ' ' +\
2453            'name: ' + repr(self.name) + ' ' +\
2454            'password: ' + repr(self.password) + ' ' +\
2455            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2456            'tags: ' + repr(self.tags) + ' ' +\
2457            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2458            '>'
2459
2460    def to_dict(self):
2461        return {
2462            'app_id': self.app_id,
2463            'bind_interface': self.bind_interface,
2464            'egress_filter': self.egress_filter,
2465            'healthy': self.healthy,
2466            'id': self.id,
2467            'name': self.name,
2468            'password': self.password,
2469            'secret_store_id': self.secret_store_id,
2470            'tags': self.tags,
2471            'tenant_id': self.tenant_id,
2472        }
2473
2474    @classmethod
2475    def from_dict(cls, d):
2476        return cls(
2477            app_id=d.get('app_id'),
2478            bind_interface=d.get('bind_interface'),
2479            egress_filter=d.get('egress_filter'),
2480            healthy=d.get('healthy'),
2481            id=d.get('id'),
2482            name=d.get('name'),
2483            password=d.get('password'),
2484            secret_store_id=d.get('secret_store_id'),
2485            tags=d.get('tags'),
2486            tenant_id=d.get('tenant_id'),
2487        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2401    def __init__(
2402        self,
2403        app_id=None,
2404        bind_interface=None,
2405        egress_filter=None,
2406        healthy=None,
2407        id=None,
2408        name=None,
2409        password=None,
2410        secret_store_id=None,
2411        tags=None,
2412        tenant_id=None,
2413    ):
2414        self.app_id = app_id if app_id is not None else ''
2415        self.bind_interface = bind_interface if bind_interface is not None else ''
2416        '''
2417         Bind interface
2418        '''
2419        self.egress_filter = egress_filter if egress_filter is not None else ''
2420        '''
2421         A filter applied to the routing logic to pin datasource to nodes.
2422        '''
2423        self.healthy = healthy if healthy is not None else False
2424        '''
2425         True if the datasource is reachable and the credentials are valid.
2426        '''
2427        self.id = id if id is not None else ''
2428        '''
2429         Unique identifier of the Resource.
2430        '''
2431        self.name = name if name is not None else ''
2432        '''
2433         Unique human-readable name of the Resource.
2434        '''
2435        self.password = password if password is not None else ''
2436        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2437        '''
2438         ID of the secret store containing credentials for this resource, if any.
2439        '''
2440        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2441        '''
2442         Tags is a map of key, value pairs.
2443        '''
2444        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2460    def to_dict(self):
2461        return {
2462            'app_id': self.app_id,
2463            'bind_interface': self.bind_interface,
2464            'egress_filter': self.egress_filter,
2465            'healthy': self.healthy,
2466            'id': self.id,
2467            'name': self.name,
2468            'password': self.password,
2469            'secret_store_id': self.secret_store_id,
2470            'tags': self.tags,
2471            'tenant_id': self.tenant_id,
2472        }
@classmethod
def from_dict(cls, d)
2474    @classmethod
2475    def from_dict(cls, d):
2476        return cls(
2477            app_id=d.get('app_id'),
2478            bind_interface=d.get('bind_interface'),
2479            egress_filter=d.get('egress_filter'),
2480            healthy=d.get('healthy'),
2481            id=d.get('id'),
2482            name=d.get('name'),
2483            password=d.get('password'),
2484            secret_store_id=d.get('secret_store_id'),
2485            tags=d.get('tags'),
2486            tenant_id=d.get('tenant_id'),
2487        )
class AzureCertificate:
2490class AzureCertificate:
2491    __slots__ = [
2492        'app_id',
2493        'bind_interface',
2494        'client_certificate',
2495        'egress_filter',
2496        'healthy',
2497        'id',
2498        'name',
2499        'secret_store_id',
2500        'tags',
2501        'tenant_id',
2502    ]
2503
2504    def __init__(
2505        self,
2506        app_id=None,
2507        bind_interface=None,
2508        client_certificate=None,
2509        egress_filter=None,
2510        healthy=None,
2511        id=None,
2512        name=None,
2513        secret_store_id=None,
2514        tags=None,
2515        tenant_id=None,
2516    ):
2517        self.app_id = app_id if app_id is not None else ''
2518        self.bind_interface = bind_interface if bind_interface is not None else ''
2519        '''
2520         Bind interface
2521        '''
2522        self.client_certificate = client_certificate if client_certificate is not None else ''
2523        self.egress_filter = egress_filter if egress_filter is not None else ''
2524        '''
2525         A filter applied to the routing logic to pin datasource to nodes.
2526        '''
2527        self.healthy = healthy if healthy is not None else False
2528        '''
2529         True if the datasource is reachable and the credentials are valid.
2530        '''
2531        self.id = id if id is not None else ''
2532        '''
2533         Unique identifier of the Resource.
2534        '''
2535        self.name = name if name is not None else ''
2536        '''
2537         Unique human-readable name of the Resource.
2538        '''
2539        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2540        '''
2541         ID of the secret store containing credentials for this resource, if any.
2542        '''
2543        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2544        '''
2545         Tags is a map of key, value pairs.
2546        '''
2547        self.tenant_id = tenant_id if tenant_id is not None else ''
2548
2549    def __repr__(self):
2550        return '<sdm.AzureCertificate ' + \
2551            'app_id: ' + repr(self.app_id) + ' ' +\
2552            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2553            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2554            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2555            'healthy: ' + repr(self.healthy) + ' ' +\
2556            'id: ' + repr(self.id) + ' ' +\
2557            'name: ' + repr(self.name) + ' ' +\
2558            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2559            'tags: ' + repr(self.tags) + ' ' +\
2560            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2561            '>'
2562
2563    def to_dict(self):
2564        return {
2565            'app_id': self.app_id,
2566            'bind_interface': self.bind_interface,
2567            'client_certificate': self.client_certificate,
2568            'egress_filter': self.egress_filter,
2569            'healthy': self.healthy,
2570            'id': self.id,
2571            'name': self.name,
2572            'secret_store_id': self.secret_store_id,
2573            'tags': self.tags,
2574            'tenant_id': self.tenant_id,
2575        }
2576
2577    @classmethod
2578    def from_dict(cls, d):
2579        return cls(
2580            app_id=d.get('app_id'),
2581            bind_interface=d.get('bind_interface'),
2582            client_certificate=d.get('client_certificate'),
2583            egress_filter=d.get('egress_filter'),
2584            healthy=d.get('healthy'),
2585            id=d.get('id'),
2586            name=d.get('name'),
2587            secret_store_id=d.get('secret_store_id'),
2588            tags=d.get('tags'),
2589            tenant_id=d.get('tenant_id'),
2590        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2504    def __init__(
2505        self,
2506        app_id=None,
2507        bind_interface=None,
2508        client_certificate=None,
2509        egress_filter=None,
2510        healthy=None,
2511        id=None,
2512        name=None,
2513        secret_store_id=None,
2514        tags=None,
2515        tenant_id=None,
2516    ):
2517        self.app_id = app_id if app_id is not None else ''
2518        self.bind_interface = bind_interface if bind_interface is not None else ''
2519        '''
2520         Bind interface
2521        '''
2522        self.client_certificate = client_certificate if client_certificate is not None else ''
2523        self.egress_filter = egress_filter if egress_filter is not None else ''
2524        '''
2525         A filter applied to the routing logic to pin datasource to nodes.
2526        '''
2527        self.healthy = healthy if healthy is not None else False
2528        '''
2529         True if the datasource is reachable and the credentials are valid.
2530        '''
2531        self.id = id if id is not None else ''
2532        '''
2533         Unique identifier of the Resource.
2534        '''
2535        self.name = name if name is not None else ''
2536        '''
2537         Unique human-readable name of the Resource.
2538        '''
2539        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2540        '''
2541         ID of the secret store containing credentials for this resource, if any.
2542        '''
2543        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2544        '''
2545         Tags is a map of key, value pairs.
2546        '''
2547        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2563    def to_dict(self):
2564        return {
2565            'app_id': self.app_id,
2566            'bind_interface': self.bind_interface,
2567            'client_certificate': self.client_certificate,
2568            'egress_filter': self.egress_filter,
2569            'healthy': self.healthy,
2570            'id': self.id,
2571            'name': self.name,
2572            'secret_store_id': self.secret_store_id,
2573            'tags': self.tags,
2574            'tenant_id': self.tenant_id,
2575        }
@classmethod
def from_dict(cls, d)
2577    @classmethod
2578    def from_dict(cls, d):
2579        return cls(
2580            app_id=d.get('app_id'),
2581            bind_interface=d.get('bind_interface'),
2582            client_certificate=d.get('client_certificate'),
2583            egress_filter=d.get('egress_filter'),
2584            healthy=d.get('healthy'),
2585            id=d.get('id'),
2586            name=d.get('name'),
2587            secret_store_id=d.get('secret_store_id'),
2588            tags=d.get('tags'),
2589            tenant_id=d.get('tenant_id'),
2590        )
class AzurePostgres:
2593class AzurePostgres:
2594    __slots__ = [
2595        'bind_interface',
2596        'database',
2597        'egress_filter',
2598        'healthy',
2599        'hostname',
2600        'id',
2601        'name',
2602        'override_database',
2603        'password',
2604        'port',
2605        'port_override',
2606        'secret_store_id',
2607        'tags',
2608        'username',
2609    ]
2610
2611    def __init__(
2612        self,
2613        bind_interface=None,
2614        database=None,
2615        egress_filter=None,
2616        healthy=None,
2617        hostname=None,
2618        id=None,
2619        name=None,
2620        override_database=None,
2621        password=None,
2622        port=None,
2623        port_override=None,
2624        secret_store_id=None,
2625        tags=None,
2626        username=None,
2627    ):
2628        self.bind_interface = bind_interface if bind_interface is not None else ''
2629        '''
2630         Bind interface
2631        '''
2632        self.database = database if database is not None else ''
2633        self.egress_filter = egress_filter if egress_filter is not None else ''
2634        '''
2635         A filter applied to the routing logic to pin datasource to nodes.
2636        '''
2637        self.healthy = healthy if healthy is not None else False
2638        '''
2639         True if the datasource is reachable and the credentials are valid.
2640        '''
2641        self.hostname = hostname if hostname is not None else ''
2642        self.id = id if id is not None else ''
2643        '''
2644         Unique identifier of the Resource.
2645        '''
2646        self.name = name if name is not None else ''
2647        '''
2648         Unique human-readable name of the Resource.
2649        '''
2650        self.override_database = override_database if override_database is not None else False
2651        self.password = password if password is not None else ''
2652        self.port = port if port is not None else 0
2653        self.port_override = port_override if port_override is not None else 0
2654        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2655        '''
2656         ID of the secret store containing credentials for this resource, if any.
2657        '''
2658        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2659        '''
2660         Tags is a map of key, value pairs.
2661        '''
2662        self.username = username if username is not None else ''
2663
2664    def __repr__(self):
2665        return '<sdm.AzurePostgres ' + \
2666            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2667            'database: ' + repr(self.database) + ' ' +\
2668            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2669            'healthy: ' + repr(self.healthy) + ' ' +\
2670            'hostname: ' + repr(self.hostname) + ' ' +\
2671            'id: ' + repr(self.id) + ' ' +\
2672            'name: ' + repr(self.name) + ' ' +\
2673            'override_database: ' + repr(self.override_database) + ' ' +\
2674            'password: ' + repr(self.password) + ' ' +\
2675            'port: ' + repr(self.port) + ' ' +\
2676            'port_override: ' + repr(self.port_override) + ' ' +\
2677            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2678            'tags: ' + repr(self.tags) + ' ' +\
2679            'username: ' + repr(self.username) + ' ' +\
2680            '>'
2681
2682    def to_dict(self):
2683        return {
2684            'bind_interface': self.bind_interface,
2685            'database': self.database,
2686            'egress_filter': self.egress_filter,
2687            'healthy': self.healthy,
2688            'hostname': self.hostname,
2689            'id': self.id,
2690            'name': self.name,
2691            'override_database': self.override_database,
2692            'password': self.password,
2693            'port': self.port,
2694            'port_override': self.port_override,
2695            'secret_store_id': self.secret_store_id,
2696            'tags': self.tags,
2697            'username': self.username,
2698        }
2699
2700    @classmethod
2701    def from_dict(cls, d):
2702        return cls(
2703            bind_interface=d.get('bind_interface'),
2704            database=d.get('database'),
2705            egress_filter=d.get('egress_filter'),
2706            healthy=d.get('healthy'),
2707            hostname=d.get('hostname'),
2708            id=d.get('id'),
2709            name=d.get('name'),
2710            override_database=d.get('override_database'),
2711            password=d.get('password'),
2712            port=d.get('port'),
2713            port_override=d.get('port_override'),
2714            secret_store_id=d.get('secret_store_id'),
2715            tags=d.get('tags'),
2716            username=d.get('username'),
2717        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2611    def __init__(
2612        self,
2613        bind_interface=None,
2614        database=None,
2615        egress_filter=None,
2616        healthy=None,
2617        hostname=None,
2618        id=None,
2619        name=None,
2620        override_database=None,
2621        password=None,
2622        port=None,
2623        port_override=None,
2624        secret_store_id=None,
2625        tags=None,
2626        username=None,
2627    ):
2628        self.bind_interface = bind_interface if bind_interface is not None else ''
2629        '''
2630         Bind interface
2631        '''
2632        self.database = database if database is not None else ''
2633        self.egress_filter = egress_filter if egress_filter is not None else ''
2634        '''
2635         A filter applied to the routing logic to pin datasource to nodes.
2636        '''
2637        self.healthy = healthy if healthy is not None else False
2638        '''
2639         True if the datasource is reachable and the credentials are valid.
2640        '''
2641        self.hostname = hostname if hostname is not None else ''
2642        self.id = id if id is not None else ''
2643        '''
2644         Unique identifier of the Resource.
2645        '''
2646        self.name = name if name is not None else ''
2647        '''
2648         Unique human-readable name of the Resource.
2649        '''
2650        self.override_database = override_database if override_database is not None else False
2651        self.password = password if password is not None else ''
2652        self.port = port if port is not None else 0
2653        self.port_override = port_override if port_override is not None else 0
2654        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2655        '''
2656         ID of the secret store containing credentials for this resource, if any.
2657        '''
2658        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2659        '''
2660         Tags is a map of key, value pairs.
2661        '''
2662        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2682    def to_dict(self):
2683        return {
2684            'bind_interface': self.bind_interface,
2685            'database': self.database,
2686            'egress_filter': self.egress_filter,
2687            'healthy': self.healthy,
2688            'hostname': self.hostname,
2689            'id': self.id,
2690            'name': self.name,
2691            'override_database': self.override_database,
2692            'password': self.password,
2693            'port': self.port,
2694            'port_override': self.port_override,
2695            'secret_store_id': self.secret_store_id,
2696            'tags': self.tags,
2697            'username': self.username,
2698        }
@classmethod
def from_dict(cls, d)
2700    @classmethod
2701    def from_dict(cls, d):
2702        return cls(
2703            bind_interface=d.get('bind_interface'),
2704            database=d.get('database'),
2705            egress_filter=d.get('egress_filter'),
2706            healthy=d.get('healthy'),
2707            hostname=d.get('hostname'),
2708            id=d.get('id'),
2709            name=d.get('name'),
2710            override_database=d.get('override_database'),
2711            password=d.get('password'),
2712            port=d.get('port'),
2713            port_override=d.get('port_override'),
2714            secret_store_id=d.get('secret_store_id'),
2715            tags=d.get('tags'),
2716            username=d.get('username'),
2717        )
class AzureStore:
2720class AzureStore:
2721    __slots__ = [
2722        'id',
2723        'name',
2724        'tags',
2725        'vault_uri',
2726    ]
2727
2728    def __init__(
2729        self,
2730        id=None,
2731        name=None,
2732        tags=None,
2733        vault_uri=None,
2734    ):
2735        self.id = id if id is not None else ''
2736        '''
2737         Unique identifier of the SecretStore.
2738        '''
2739        self.name = name if name is not None else ''
2740        '''
2741         Unique human-readable name of the SecretStore.
2742        '''
2743        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2744        '''
2745         Tags is a map of key, value pairs.
2746        '''
2747        self.vault_uri = vault_uri if vault_uri is not None else ''
2748
2749    def __repr__(self):
2750        return '<sdm.AzureStore ' + \
2751            'id: ' + repr(self.id) + ' ' +\
2752            'name: ' + repr(self.name) + ' ' +\
2753            'tags: ' + repr(self.tags) + ' ' +\
2754            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
2755            '>'
2756
2757    def to_dict(self):
2758        return {
2759            'id': self.id,
2760            'name': self.name,
2761            'tags': self.tags,
2762            'vault_uri': self.vault_uri,
2763        }
2764
2765    @classmethod
2766    def from_dict(cls, d):
2767        return cls(
2768            id=d.get('id'),
2769            name=d.get('name'),
2770            tags=d.get('tags'),
2771            vault_uri=d.get('vault_uri'),
2772        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
2728    def __init__(
2729        self,
2730        id=None,
2731        name=None,
2732        tags=None,
2733        vault_uri=None,
2734    ):
2735        self.id = id if id is not None else ''
2736        '''
2737         Unique identifier of the SecretStore.
2738        '''
2739        self.name = name if name is not None else ''
2740        '''
2741         Unique human-readable name of the SecretStore.
2742        '''
2743        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2744        '''
2745         Tags is a map of key, value pairs.
2746        '''
2747        self.vault_uri = vault_uri if vault_uri is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
2757    def to_dict(self):
2758        return {
2759            'id': self.id,
2760            'name': self.name,
2761            'tags': self.tags,
2762            'vault_uri': self.vault_uri,
2763        }
@classmethod
def from_dict(cls, d)
2765    @classmethod
2766    def from_dict(cls, d):
2767        return cls(
2768            id=d.get('id'),
2769            name=d.get('name'),
2770            tags=d.get('tags'),
2771            vault_uri=d.get('vault_uri'),
2772        )
class BigQuery:
2775class BigQuery:
2776    __slots__ = [
2777        'bind_interface',
2778        'egress_filter',
2779        'endpoint',
2780        'healthy',
2781        'id',
2782        'name',
2783        'port_override',
2784        'private_key',
2785        'project',
2786        'secret_store_id',
2787        'tags',
2788        'username',
2789    ]
2790
2791    def __init__(
2792        self,
2793        bind_interface=None,
2794        egress_filter=None,
2795        endpoint=None,
2796        healthy=None,
2797        id=None,
2798        name=None,
2799        port_override=None,
2800        private_key=None,
2801        project=None,
2802        secret_store_id=None,
2803        tags=None,
2804        username=None,
2805    ):
2806        self.bind_interface = bind_interface if bind_interface is not None else ''
2807        '''
2808         Bind interface
2809        '''
2810        self.egress_filter = egress_filter if egress_filter is not None else ''
2811        '''
2812         A filter applied to the routing logic to pin datasource to nodes.
2813        '''
2814        self.endpoint = endpoint if endpoint is not None else ''
2815        self.healthy = healthy if healthy is not None else False
2816        '''
2817         True if the datasource is reachable and the credentials are valid.
2818        '''
2819        self.id = id if id is not None else ''
2820        '''
2821         Unique identifier of the Resource.
2822        '''
2823        self.name = name if name is not None else ''
2824        '''
2825         Unique human-readable name of the Resource.
2826        '''
2827        self.port_override = port_override if port_override is not None else 0
2828        self.private_key = private_key if private_key is not None else ''
2829        self.project = project if project is not None else ''
2830        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2831        '''
2832         ID of the secret store containing credentials for this resource, if any.
2833        '''
2834        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2835        '''
2836         Tags is a map of key, value pairs.
2837        '''
2838        self.username = username if username is not None else ''
2839
2840    def __repr__(self):
2841        return '<sdm.BigQuery ' + \
2842            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2843            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2844            'endpoint: ' + repr(self.endpoint) + ' ' +\
2845            'healthy: ' + repr(self.healthy) + ' ' +\
2846            'id: ' + repr(self.id) + ' ' +\
2847            'name: ' + repr(self.name) + ' ' +\
2848            'port_override: ' + repr(self.port_override) + ' ' +\
2849            'private_key: ' + repr(self.private_key) + ' ' +\
2850            'project: ' + repr(self.project) + ' ' +\
2851            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2852            'tags: ' + repr(self.tags) + ' ' +\
2853            'username: ' + repr(self.username) + ' ' +\
2854            '>'
2855
2856    def to_dict(self):
2857        return {
2858            'bind_interface': self.bind_interface,
2859            'egress_filter': self.egress_filter,
2860            'endpoint': self.endpoint,
2861            'healthy': self.healthy,
2862            'id': self.id,
2863            'name': self.name,
2864            'port_override': self.port_override,
2865            'private_key': self.private_key,
2866            'project': self.project,
2867            'secret_store_id': self.secret_store_id,
2868            'tags': self.tags,
2869            'username': self.username,
2870        }
2871
2872    @classmethod
2873    def from_dict(cls, d):
2874        return cls(
2875            bind_interface=d.get('bind_interface'),
2876            egress_filter=d.get('egress_filter'),
2877            endpoint=d.get('endpoint'),
2878            healthy=d.get('healthy'),
2879            id=d.get('id'),
2880            name=d.get('name'),
2881            port_override=d.get('port_override'),
2882            private_key=d.get('private_key'),
2883            project=d.get('project'),
2884            secret_store_id=d.get('secret_store_id'),
2885            tags=d.get('tags'),
2886            username=d.get('username'),
2887        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
2791    def __init__(
2792        self,
2793        bind_interface=None,
2794        egress_filter=None,
2795        endpoint=None,
2796        healthy=None,
2797        id=None,
2798        name=None,
2799        port_override=None,
2800        private_key=None,
2801        project=None,
2802        secret_store_id=None,
2803        tags=None,
2804        username=None,
2805    ):
2806        self.bind_interface = bind_interface if bind_interface is not None else ''
2807        '''
2808         Bind interface
2809        '''
2810        self.egress_filter = egress_filter if egress_filter is not None else ''
2811        '''
2812         A filter applied to the routing logic to pin datasource to nodes.
2813        '''
2814        self.endpoint = endpoint if endpoint is not None else ''
2815        self.healthy = healthy if healthy is not None else False
2816        '''
2817         True if the datasource is reachable and the credentials are valid.
2818        '''
2819        self.id = id if id is not None else ''
2820        '''
2821         Unique identifier of the Resource.
2822        '''
2823        self.name = name if name is not None else ''
2824        '''
2825         Unique human-readable name of the Resource.
2826        '''
2827        self.port_override = port_override if port_override is not None else 0
2828        self.private_key = private_key if private_key is not None else ''
2829        self.project = project if project is not None else ''
2830        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2831        '''
2832         ID of the secret store containing credentials for this resource, if any.
2833        '''
2834        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2835        '''
2836         Tags is a map of key, value pairs.
2837        '''
2838        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2856    def to_dict(self):
2857        return {
2858            'bind_interface': self.bind_interface,
2859            'egress_filter': self.egress_filter,
2860            'endpoint': self.endpoint,
2861            'healthy': self.healthy,
2862            'id': self.id,
2863            'name': self.name,
2864            'port_override': self.port_override,
2865            'private_key': self.private_key,
2866            'project': self.project,
2867            'secret_store_id': self.secret_store_id,
2868            'tags': self.tags,
2869            'username': self.username,
2870        }
@classmethod
def from_dict(cls, d)
2872    @classmethod
2873    def from_dict(cls, d):
2874        return cls(
2875            bind_interface=d.get('bind_interface'),
2876            egress_filter=d.get('egress_filter'),
2877            endpoint=d.get('endpoint'),
2878            healthy=d.get('healthy'),
2879            id=d.get('id'),
2880            name=d.get('name'),
2881            port_override=d.get('port_override'),
2882            private_key=d.get('private_key'),
2883            project=d.get('project'),
2884            secret_store_id=d.get('secret_store_id'),
2885            tags=d.get('tags'),
2886            username=d.get('username'),
2887        )
class Cassandra:
2890class Cassandra:
2891    __slots__ = [
2892        'bind_interface',
2893        'egress_filter',
2894        'healthy',
2895        'hostname',
2896        'id',
2897        'name',
2898        'password',
2899        'port',
2900        'port_override',
2901        'secret_store_id',
2902        'tags',
2903        'tls_required',
2904        'username',
2905    ]
2906
2907    def __init__(
2908        self,
2909        bind_interface=None,
2910        egress_filter=None,
2911        healthy=None,
2912        hostname=None,
2913        id=None,
2914        name=None,
2915        password=None,
2916        port=None,
2917        port_override=None,
2918        secret_store_id=None,
2919        tags=None,
2920        tls_required=None,
2921        username=None,
2922    ):
2923        self.bind_interface = bind_interface if bind_interface is not None else ''
2924        '''
2925         Bind interface
2926        '''
2927        self.egress_filter = egress_filter if egress_filter is not None else ''
2928        '''
2929         A filter applied to the routing logic to pin datasource to nodes.
2930        '''
2931        self.healthy = healthy if healthy is not None else False
2932        '''
2933         True if the datasource is reachable and the credentials are valid.
2934        '''
2935        self.hostname = hostname if hostname is not None else ''
2936        self.id = id if id is not None else ''
2937        '''
2938         Unique identifier of the Resource.
2939        '''
2940        self.name = name if name is not None else ''
2941        '''
2942         Unique human-readable name of the Resource.
2943        '''
2944        self.password = password if password is not None else ''
2945        self.port = port if port is not None else 0
2946        self.port_override = port_override if port_override is not None else 0
2947        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2948        '''
2949         ID of the secret store containing credentials for this resource, if any.
2950        '''
2951        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2952        '''
2953         Tags is a map of key, value pairs.
2954        '''
2955        self.tls_required = tls_required if tls_required is not None else False
2956        self.username = username if username is not None else ''
2957
2958    def __repr__(self):
2959        return '<sdm.Cassandra ' + \
2960            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2961            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2962            'healthy: ' + repr(self.healthy) + ' ' +\
2963            'hostname: ' + repr(self.hostname) + ' ' +\
2964            'id: ' + repr(self.id) + ' ' +\
2965            'name: ' + repr(self.name) + ' ' +\
2966            'password: ' + repr(self.password) + ' ' +\
2967            'port: ' + repr(self.port) + ' ' +\
2968            'port_override: ' + repr(self.port_override) + ' ' +\
2969            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2970            'tags: ' + repr(self.tags) + ' ' +\
2971            'tls_required: ' + repr(self.tls_required) + ' ' +\
2972            'username: ' + repr(self.username) + ' ' +\
2973            '>'
2974
2975    def to_dict(self):
2976        return {
2977            'bind_interface': self.bind_interface,
2978            'egress_filter': self.egress_filter,
2979            'healthy': self.healthy,
2980            'hostname': self.hostname,
2981            'id': self.id,
2982            'name': self.name,
2983            'password': self.password,
2984            'port': self.port,
2985            'port_override': self.port_override,
2986            'secret_store_id': self.secret_store_id,
2987            'tags': self.tags,
2988            'tls_required': self.tls_required,
2989            'username': self.username,
2990        }
2991
2992    @classmethod
2993    def from_dict(cls, d):
2994        return cls(
2995            bind_interface=d.get('bind_interface'),
2996            egress_filter=d.get('egress_filter'),
2997            healthy=d.get('healthy'),
2998            hostname=d.get('hostname'),
2999            id=d.get('id'),
3000            name=d.get('name'),
3001            password=d.get('password'),
3002            port=d.get('port'),
3003            port_override=d.get('port_override'),
3004            secret_store_id=d.get('secret_store_id'),
3005            tags=d.get('tags'),
3006            tls_required=d.get('tls_required'),
3007            username=d.get('username'),
3008        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2907    def __init__(
2908        self,
2909        bind_interface=None,
2910        egress_filter=None,
2911        healthy=None,
2912        hostname=None,
2913        id=None,
2914        name=None,
2915        password=None,
2916        port=None,
2917        port_override=None,
2918        secret_store_id=None,
2919        tags=None,
2920        tls_required=None,
2921        username=None,
2922    ):
2923        self.bind_interface = bind_interface if bind_interface is not None else ''
2924        '''
2925         Bind interface
2926        '''
2927        self.egress_filter = egress_filter if egress_filter is not None else ''
2928        '''
2929         A filter applied to the routing logic to pin datasource to nodes.
2930        '''
2931        self.healthy = healthy if healthy is not None else False
2932        '''
2933         True if the datasource is reachable and the credentials are valid.
2934        '''
2935        self.hostname = hostname if hostname is not None else ''
2936        self.id = id if id is not None else ''
2937        '''
2938         Unique identifier of the Resource.
2939        '''
2940        self.name = name if name is not None else ''
2941        '''
2942         Unique human-readable name of the Resource.
2943        '''
2944        self.password = password if password is not None else ''
2945        self.port = port if port is not None else 0
2946        self.port_override = port_override if port_override is not None else 0
2947        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2948        '''
2949         ID of the secret store containing credentials for this resource, if any.
2950        '''
2951        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2952        '''
2953         Tags is a map of key, value pairs.
2954        '''
2955        self.tls_required = tls_required if tls_required is not None else False
2956        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2975    def to_dict(self):
2976        return {
2977            'bind_interface': self.bind_interface,
2978            'egress_filter': self.egress_filter,
2979            'healthy': self.healthy,
2980            'hostname': self.hostname,
2981            'id': self.id,
2982            'name': self.name,
2983            'password': self.password,
2984            'port': self.port,
2985            'port_override': self.port_override,
2986            'secret_store_id': self.secret_store_id,
2987            'tags': self.tags,
2988            'tls_required': self.tls_required,
2989            'username': self.username,
2990        }
@classmethod
def from_dict(cls, d)
2992    @classmethod
2993    def from_dict(cls, d):
2994        return cls(
2995            bind_interface=d.get('bind_interface'),
2996            egress_filter=d.get('egress_filter'),
2997            healthy=d.get('healthy'),
2998            hostname=d.get('hostname'),
2999            id=d.get('id'),
3000            name=d.get('name'),
3001            password=d.get('password'),
3002            port=d.get('port'),
3003            port_override=d.get('port_override'),
3004            secret_store_id=d.get('secret_store_id'),
3005            tags=d.get('tags'),
3006            tls_required=d.get('tls_required'),
3007            username=d.get('username'),
3008        )
class Citus:
3011class Citus:
3012    __slots__ = [
3013        'bind_interface',
3014        'database',
3015        'egress_filter',
3016        'healthy',
3017        'hostname',
3018        'id',
3019        'name',
3020        'override_database',
3021        'password',
3022        'port',
3023        'port_override',
3024        'secret_store_id',
3025        'tags',
3026        'username',
3027    ]
3028
3029    def __init__(
3030        self,
3031        bind_interface=None,
3032        database=None,
3033        egress_filter=None,
3034        healthy=None,
3035        hostname=None,
3036        id=None,
3037        name=None,
3038        override_database=None,
3039        password=None,
3040        port=None,
3041        port_override=None,
3042        secret_store_id=None,
3043        tags=None,
3044        username=None,
3045    ):
3046        self.bind_interface = bind_interface if bind_interface is not None else ''
3047        '''
3048         Bind interface
3049        '''
3050        self.database = database if database is not None else ''
3051        self.egress_filter = egress_filter if egress_filter is not None else ''
3052        '''
3053         A filter applied to the routing logic to pin datasource to nodes.
3054        '''
3055        self.healthy = healthy if healthy is not None else False
3056        '''
3057         True if the datasource is reachable and the credentials are valid.
3058        '''
3059        self.hostname = hostname if hostname is not None else ''
3060        self.id = id if id is not None else ''
3061        '''
3062         Unique identifier of the Resource.
3063        '''
3064        self.name = name if name is not None else ''
3065        '''
3066         Unique human-readable name of the Resource.
3067        '''
3068        self.override_database = override_database if override_database is not None else False
3069        self.password = password if password is not None else ''
3070        self.port = port if port is not None else 0
3071        self.port_override = port_override if port_override is not None else 0
3072        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3073        '''
3074         ID of the secret store containing credentials for this resource, if any.
3075        '''
3076        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3077        '''
3078         Tags is a map of key, value pairs.
3079        '''
3080        self.username = username if username is not None else ''
3081
3082    def __repr__(self):
3083        return '<sdm.Citus ' + \
3084            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3085            'database: ' + repr(self.database) + ' ' +\
3086            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3087            'healthy: ' + repr(self.healthy) + ' ' +\
3088            'hostname: ' + repr(self.hostname) + ' ' +\
3089            'id: ' + repr(self.id) + ' ' +\
3090            'name: ' + repr(self.name) + ' ' +\
3091            'override_database: ' + repr(self.override_database) + ' ' +\
3092            'password: ' + repr(self.password) + ' ' +\
3093            'port: ' + repr(self.port) + ' ' +\
3094            'port_override: ' + repr(self.port_override) + ' ' +\
3095            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3096            'tags: ' + repr(self.tags) + ' ' +\
3097            'username: ' + repr(self.username) + ' ' +\
3098            '>'
3099
3100    def to_dict(self):
3101        return {
3102            'bind_interface': self.bind_interface,
3103            'database': self.database,
3104            'egress_filter': self.egress_filter,
3105            'healthy': self.healthy,
3106            'hostname': self.hostname,
3107            'id': self.id,
3108            'name': self.name,
3109            'override_database': self.override_database,
3110            'password': self.password,
3111            'port': self.port,
3112            'port_override': self.port_override,
3113            'secret_store_id': self.secret_store_id,
3114            'tags': self.tags,
3115            'username': self.username,
3116        }
3117
3118    @classmethod
3119    def from_dict(cls, d):
3120        return cls(
3121            bind_interface=d.get('bind_interface'),
3122            database=d.get('database'),
3123            egress_filter=d.get('egress_filter'),
3124            healthy=d.get('healthy'),
3125            hostname=d.get('hostname'),
3126            id=d.get('id'),
3127            name=d.get('name'),
3128            override_database=d.get('override_database'),
3129            password=d.get('password'),
3130            port=d.get('port'),
3131            port_override=d.get('port_override'),
3132            secret_store_id=d.get('secret_store_id'),
3133            tags=d.get('tags'),
3134            username=d.get('username'),
3135        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3029    def __init__(
3030        self,
3031        bind_interface=None,
3032        database=None,
3033        egress_filter=None,
3034        healthy=None,
3035        hostname=None,
3036        id=None,
3037        name=None,
3038        override_database=None,
3039        password=None,
3040        port=None,
3041        port_override=None,
3042        secret_store_id=None,
3043        tags=None,
3044        username=None,
3045    ):
3046        self.bind_interface = bind_interface if bind_interface is not None else ''
3047        '''
3048         Bind interface
3049        '''
3050        self.database = database if database is not None else ''
3051        self.egress_filter = egress_filter if egress_filter is not None else ''
3052        '''
3053         A filter applied to the routing logic to pin datasource to nodes.
3054        '''
3055        self.healthy = healthy if healthy is not None else False
3056        '''
3057         True if the datasource is reachable and the credentials are valid.
3058        '''
3059        self.hostname = hostname if hostname is not None else ''
3060        self.id = id if id is not None else ''
3061        '''
3062         Unique identifier of the Resource.
3063        '''
3064        self.name = name if name is not None else ''
3065        '''
3066         Unique human-readable name of the Resource.
3067        '''
3068        self.override_database = override_database if override_database is not None else False
3069        self.password = password if password is not None else ''
3070        self.port = port if port is not None else 0
3071        self.port_override = port_override if port_override is not None else 0
3072        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3073        '''
3074         ID of the secret store containing credentials for this resource, if any.
3075        '''
3076        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3077        '''
3078         Tags is a map of key, value pairs.
3079        '''
3080        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3100    def to_dict(self):
3101        return {
3102            'bind_interface': self.bind_interface,
3103            'database': self.database,
3104            'egress_filter': self.egress_filter,
3105            'healthy': self.healthy,
3106            'hostname': self.hostname,
3107            'id': self.id,
3108            'name': self.name,
3109            'override_database': self.override_database,
3110            'password': self.password,
3111            'port': self.port,
3112            'port_override': self.port_override,
3113            'secret_store_id': self.secret_store_id,
3114            'tags': self.tags,
3115            'username': self.username,
3116        }
@classmethod
def from_dict(cls, d)
3118    @classmethod
3119    def from_dict(cls, d):
3120        return cls(
3121            bind_interface=d.get('bind_interface'),
3122            database=d.get('database'),
3123            egress_filter=d.get('egress_filter'),
3124            healthy=d.get('healthy'),
3125            hostname=d.get('hostname'),
3126            id=d.get('id'),
3127            name=d.get('name'),
3128            override_database=d.get('override_database'),
3129            password=d.get('password'),
3130            port=d.get('port'),
3131            port_override=d.get('port_override'),
3132            secret_store_id=d.get('secret_store_id'),
3133            tags=d.get('tags'),
3134            username=d.get('username'),
3135        )
class Clustrix:
3138class Clustrix:
3139    __slots__ = [
3140        'bind_interface',
3141        'database',
3142        'egress_filter',
3143        'healthy',
3144        'hostname',
3145        'id',
3146        'name',
3147        'password',
3148        'port',
3149        'port_override',
3150        'secret_store_id',
3151        'tags',
3152        'username',
3153    ]
3154
3155    def __init__(
3156        self,
3157        bind_interface=None,
3158        database=None,
3159        egress_filter=None,
3160        healthy=None,
3161        hostname=None,
3162        id=None,
3163        name=None,
3164        password=None,
3165        port=None,
3166        port_override=None,
3167        secret_store_id=None,
3168        tags=None,
3169        username=None,
3170    ):
3171        self.bind_interface = bind_interface if bind_interface is not None else ''
3172        '''
3173         Bind interface
3174        '''
3175        self.database = database if database is not None else ''
3176        self.egress_filter = egress_filter if egress_filter is not None else ''
3177        '''
3178         A filter applied to the routing logic to pin datasource to nodes.
3179        '''
3180        self.healthy = healthy if healthy is not None else False
3181        '''
3182         True if the datasource is reachable and the credentials are valid.
3183        '''
3184        self.hostname = hostname if hostname is not None else ''
3185        self.id = id if id is not None else ''
3186        '''
3187         Unique identifier of the Resource.
3188        '''
3189        self.name = name if name is not None else ''
3190        '''
3191         Unique human-readable name of the Resource.
3192        '''
3193        self.password = password if password is not None else ''
3194        self.port = port if port is not None else 0
3195        self.port_override = port_override if port_override is not None else 0
3196        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3197        '''
3198         ID of the secret store containing credentials for this resource, if any.
3199        '''
3200        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3201        '''
3202         Tags is a map of key, value pairs.
3203        '''
3204        self.username = username if username is not None else ''
3205
3206    def __repr__(self):
3207        return '<sdm.Clustrix ' + \
3208            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3209            'database: ' + repr(self.database) + ' ' +\
3210            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3211            'healthy: ' + repr(self.healthy) + ' ' +\
3212            'hostname: ' + repr(self.hostname) + ' ' +\
3213            'id: ' + repr(self.id) + ' ' +\
3214            'name: ' + repr(self.name) + ' ' +\
3215            'password: ' + repr(self.password) + ' ' +\
3216            'port: ' + repr(self.port) + ' ' +\
3217            'port_override: ' + repr(self.port_override) + ' ' +\
3218            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3219            'tags: ' + repr(self.tags) + ' ' +\
3220            'username: ' + repr(self.username) + ' ' +\
3221            '>'
3222
3223    def to_dict(self):
3224        return {
3225            'bind_interface': self.bind_interface,
3226            'database': self.database,
3227            'egress_filter': self.egress_filter,
3228            'healthy': self.healthy,
3229            'hostname': self.hostname,
3230            'id': self.id,
3231            'name': self.name,
3232            'password': self.password,
3233            'port': self.port,
3234            'port_override': self.port_override,
3235            'secret_store_id': self.secret_store_id,
3236            'tags': self.tags,
3237            'username': self.username,
3238        }
3239
3240    @classmethod
3241    def from_dict(cls, d):
3242        return cls(
3243            bind_interface=d.get('bind_interface'),
3244            database=d.get('database'),
3245            egress_filter=d.get('egress_filter'),
3246            healthy=d.get('healthy'),
3247            hostname=d.get('hostname'),
3248            id=d.get('id'),
3249            name=d.get('name'),
3250            password=d.get('password'),
3251            port=d.get('port'),
3252            port_override=d.get('port_override'),
3253            secret_store_id=d.get('secret_store_id'),
3254            tags=d.get('tags'),
3255            username=d.get('username'),
3256        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3155    def __init__(
3156        self,
3157        bind_interface=None,
3158        database=None,
3159        egress_filter=None,
3160        healthy=None,
3161        hostname=None,
3162        id=None,
3163        name=None,
3164        password=None,
3165        port=None,
3166        port_override=None,
3167        secret_store_id=None,
3168        tags=None,
3169        username=None,
3170    ):
3171        self.bind_interface = bind_interface if bind_interface is not None else ''
3172        '''
3173         Bind interface
3174        '''
3175        self.database = database if database is not None else ''
3176        self.egress_filter = egress_filter if egress_filter is not None else ''
3177        '''
3178         A filter applied to the routing logic to pin datasource to nodes.
3179        '''
3180        self.healthy = healthy if healthy is not None else False
3181        '''
3182         True if the datasource is reachable and the credentials are valid.
3183        '''
3184        self.hostname = hostname if hostname is not None else ''
3185        self.id = id if id is not None else ''
3186        '''
3187         Unique identifier of the Resource.
3188        '''
3189        self.name = name if name is not None else ''
3190        '''
3191         Unique human-readable name of the Resource.
3192        '''
3193        self.password = password if password is not None else ''
3194        self.port = port if port is not None else 0
3195        self.port_override = port_override if port_override is not None else 0
3196        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3197        '''
3198         ID of the secret store containing credentials for this resource, if any.
3199        '''
3200        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3201        '''
3202         Tags is a map of key, value pairs.
3203        '''
3204        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3223    def to_dict(self):
3224        return {
3225            'bind_interface': self.bind_interface,
3226            'database': self.database,
3227            'egress_filter': self.egress_filter,
3228            'healthy': self.healthy,
3229            'hostname': self.hostname,
3230            'id': self.id,
3231            'name': self.name,
3232            'password': self.password,
3233            'port': self.port,
3234            'port_override': self.port_override,
3235            'secret_store_id': self.secret_store_id,
3236            'tags': self.tags,
3237            'username': self.username,
3238        }
@classmethod
def from_dict(cls, d)
3240    @classmethod
3241    def from_dict(cls, d):
3242        return cls(
3243            bind_interface=d.get('bind_interface'),
3244            database=d.get('database'),
3245            egress_filter=d.get('egress_filter'),
3246            healthy=d.get('healthy'),
3247            hostname=d.get('hostname'),
3248            id=d.get('id'),
3249            name=d.get('name'),
3250            password=d.get('password'),
3251            port=d.get('port'),
3252            port_override=d.get('port_override'),
3253            secret_store_id=d.get('secret_store_id'),
3254            tags=d.get('tags'),
3255            username=d.get('username'),
3256        )
class Cockroach:
3259class Cockroach:
3260    __slots__ = [
3261        'bind_interface',
3262        'database',
3263        'egress_filter',
3264        'healthy',
3265        'hostname',
3266        'id',
3267        'name',
3268        'override_database',
3269        'password',
3270        'port',
3271        'port_override',
3272        'secret_store_id',
3273        'tags',
3274        'username',
3275    ]
3276
3277    def __init__(
3278        self,
3279        bind_interface=None,
3280        database=None,
3281        egress_filter=None,
3282        healthy=None,
3283        hostname=None,
3284        id=None,
3285        name=None,
3286        override_database=None,
3287        password=None,
3288        port=None,
3289        port_override=None,
3290        secret_store_id=None,
3291        tags=None,
3292        username=None,
3293    ):
3294        self.bind_interface = bind_interface if bind_interface is not None else ''
3295        '''
3296         Bind interface
3297        '''
3298        self.database = database if database is not None else ''
3299        self.egress_filter = egress_filter if egress_filter is not None else ''
3300        '''
3301         A filter applied to the routing logic to pin datasource to nodes.
3302        '''
3303        self.healthy = healthy if healthy is not None else False
3304        '''
3305         True if the datasource is reachable and the credentials are valid.
3306        '''
3307        self.hostname = hostname if hostname is not None else ''
3308        self.id = id if id is not None else ''
3309        '''
3310         Unique identifier of the Resource.
3311        '''
3312        self.name = name if name is not None else ''
3313        '''
3314         Unique human-readable name of the Resource.
3315        '''
3316        self.override_database = override_database if override_database is not None else False
3317        self.password = password if password is not None else ''
3318        self.port = port if port is not None else 0
3319        self.port_override = port_override if port_override is not None else 0
3320        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3321        '''
3322         ID of the secret store containing credentials for this resource, if any.
3323        '''
3324        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3325        '''
3326         Tags is a map of key, value pairs.
3327        '''
3328        self.username = username if username is not None else ''
3329
3330    def __repr__(self):
3331        return '<sdm.Cockroach ' + \
3332            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3333            'database: ' + repr(self.database) + ' ' +\
3334            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3335            'healthy: ' + repr(self.healthy) + ' ' +\
3336            'hostname: ' + repr(self.hostname) + ' ' +\
3337            'id: ' + repr(self.id) + ' ' +\
3338            'name: ' + repr(self.name) + ' ' +\
3339            'override_database: ' + repr(self.override_database) + ' ' +\
3340            'password: ' + repr(self.password) + ' ' +\
3341            'port: ' + repr(self.port) + ' ' +\
3342            'port_override: ' + repr(self.port_override) + ' ' +\
3343            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3344            'tags: ' + repr(self.tags) + ' ' +\
3345            'username: ' + repr(self.username) + ' ' +\
3346            '>'
3347
3348    def to_dict(self):
3349        return {
3350            'bind_interface': self.bind_interface,
3351            'database': self.database,
3352            'egress_filter': self.egress_filter,
3353            'healthy': self.healthy,
3354            'hostname': self.hostname,
3355            'id': self.id,
3356            'name': self.name,
3357            'override_database': self.override_database,
3358            'password': self.password,
3359            'port': self.port,
3360            'port_override': self.port_override,
3361            'secret_store_id': self.secret_store_id,
3362            'tags': self.tags,
3363            'username': self.username,
3364        }
3365
3366    @classmethod
3367    def from_dict(cls, d):
3368        return cls(
3369            bind_interface=d.get('bind_interface'),
3370            database=d.get('database'),
3371            egress_filter=d.get('egress_filter'),
3372            healthy=d.get('healthy'),
3373            hostname=d.get('hostname'),
3374            id=d.get('id'),
3375            name=d.get('name'),
3376            override_database=d.get('override_database'),
3377            password=d.get('password'),
3378            port=d.get('port'),
3379            port_override=d.get('port_override'),
3380            secret_store_id=d.get('secret_store_id'),
3381            tags=d.get('tags'),
3382            username=d.get('username'),
3383        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3277    def __init__(
3278        self,
3279        bind_interface=None,
3280        database=None,
3281        egress_filter=None,
3282        healthy=None,
3283        hostname=None,
3284        id=None,
3285        name=None,
3286        override_database=None,
3287        password=None,
3288        port=None,
3289        port_override=None,
3290        secret_store_id=None,
3291        tags=None,
3292        username=None,
3293    ):
3294        self.bind_interface = bind_interface if bind_interface is not None else ''
3295        '''
3296         Bind interface
3297        '''
3298        self.database = database if database is not None else ''
3299        self.egress_filter = egress_filter if egress_filter is not None else ''
3300        '''
3301         A filter applied to the routing logic to pin datasource to nodes.
3302        '''
3303        self.healthy = healthy if healthy is not None else False
3304        '''
3305         True if the datasource is reachable and the credentials are valid.
3306        '''
3307        self.hostname = hostname if hostname is not None else ''
3308        self.id = id if id is not None else ''
3309        '''
3310         Unique identifier of the Resource.
3311        '''
3312        self.name = name if name is not None else ''
3313        '''
3314         Unique human-readable name of the Resource.
3315        '''
3316        self.override_database = override_database if override_database is not None else False
3317        self.password = password if password is not None else ''
3318        self.port = port if port is not None else 0
3319        self.port_override = port_override if port_override is not None else 0
3320        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3321        '''
3322         ID of the secret store containing credentials for this resource, if any.
3323        '''
3324        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3325        '''
3326         Tags is a map of key, value pairs.
3327        '''
3328        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3348    def to_dict(self):
3349        return {
3350            'bind_interface': self.bind_interface,
3351            'database': self.database,
3352            'egress_filter': self.egress_filter,
3353            'healthy': self.healthy,
3354            'hostname': self.hostname,
3355            'id': self.id,
3356            'name': self.name,
3357            'override_database': self.override_database,
3358            'password': self.password,
3359            'port': self.port,
3360            'port_override': self.port_override,
3361            'secret_store_id': self.secret_store_id,
3362            'tags': self.tags,
3363            'username': self.username,
3364        }
@classmethod
def from_dict(cls, d)
3366    @classmethod
3367    def from_dict(cls, d):
3368        return cls(
3369            bind_interface=d.get('bind_interface'),
3370            database=d.get('database'),
3371            egress_filter=d.get('egress_filter'),
3372            healthy=d.get('healthy'),
3373            hostname=d.get('hostname'),
3374            id=d.get('id'),
3375            name=d.get('name'),
3376            override_database=d.get('override_database'),
3377            password=d.get('password'),
3378            port=d.get('port'),
3379            port_override=d.get('port_override'),
3380            secret_store_id=d.get('secret_store_id'),
3381            tags=d.get('tags'),
3382            username=d.get('username'),
3383        )
class ConjurStore:
3386class ConjurStore:
3387    '''
3388    ConjurStore is currently unstable, and its API may change, or it may be removed,
3389    without a major version bump.
3390    '''
3391    __slots__ = [
3392        'appurl',
3393        'id',
3394        'name',
3395        'tags',
3396    ]
3397
3398    def __init__(
3399        self,
3400        appurl=None,
3401        id=None,
3402        name=None,
3403        tags=None,
3404    ):
3405        self.appurl = appurl if appurl is not None else ''
3406        self.id = id if id is not None else ''
3407        '''
3408         Unique identifier of the SecretStore.
3409        '''
3410        self.name = name if name is not None else ''
3411        '''
3412         Unique human-readable name of the SecretStore.
3413        '''
3414        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3415        '''
3416         Tags is a map of key, value pairs.
3417        '''
3418
3419    def __repr__(self):
3420        return '<sdm.ConjurStore ' + \
3421            'appurl: ' + repr(self.appurl) + ' ' +\
3422            'id: ' + repr(self.id) + ' ' +\
3423            'name: ' + repr(self.name) + ' ' +\
3424            'tags: ' + repr(self.tags) + ' ' +\
3425            '>'
3426
3427    def to_dict(self):
3428        return {
3429            'appurl': self.appurl,
3430            'id': self.id,
3431            'name': self.name,
3432            'tags': self.tags,
3433        }
3434
3435    @classmethod
3436    def from_dict(cls, d):
3437        return cls(
3438            appurl=d.get('appurl'),
3439            id=d.get('id'),
3440            name=d.get('name'),
3441            tags=d.get('tags'),
3442        )

ConjurStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

ConjurStore(appurl=None, id=None, name=None, tags=None)
3398    def __init__(
3399        self,
3400        appurl=None,
3401        id=None,
3402        name=None,
3403        tags=None,
3404    ):
3405        self.appurl = appurl if appurl is not None else ''
3406        self.id = id if id is not None else ''
3407        '''
3408         Unique identifier of the SecretStore.
3409        '''
3410        self.name = name if name is not None else ''
3411        '''
3412         Unique human-readable name of the SecretStore.
3413        '''
3414        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3415        '''
3416         Tags is a map of key, value pairs.
3417        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
3427    def to_dict(self):
3428        return {
3429            'appurl': self.appurl,
3430            'id': self.id,
3431            'name': self.name,
3432            'tags': self.tags,
3433        }
@classmethod
def from_dict(cls, d)
3435    @classmethod
3436    def from_dict(cls, d):
3437        return cls(
3438            appurl=d.get('appurl'),
3439            id=d.get('id'),
3440            name=d.get('name'),
3441            tags=d.get('tags'),
3442        )
class ControlPanelGetSSHCAPublicKeyResponse:
3445class ControlPanelGetSSHCAPublicKeyResponse:
3446    '''
3447         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3448     organization's SSH Certificate Authority public key.
3449    '''
3450    __slots__ = [
3451        'meta',
3452        'public_key',
3453        'rate_limit',
3454    ]
3455
3456    def __init__(
3457        self,
3458        meta=None,
3459        public_key=None,
3460        rate_limit=None,
3461    ):
3462        self.meta = meta if meta is not None else None
3463        '''
3464         Reserved for future use.
3465        '''
3466        self.public_key = public_key if public_key is not None else ''
3467        '''
3468         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3469         key format.
3470        '''
3471        self.rate_limit = rate_limit if rate_limit is not None else None
3472        '''
3473         Rate limit information.
3474        '''
3475
3476    def __repr__(self):
3477        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3478            'meta: ' + repr(self.meta) + ' ' +\
3479            'public_key: ' + repr(self.public_key) + ' ' +\
3480            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3481            '>'
3482
3483    def to_dict(self):
3484        return {
3485            'meta': self.meta,
3486            'public_key': self.public_key,
3487            'rate_limit': self.rate_limit,
3488        }
3489
3490    @classmethod
3491    def from_dict(cls, d):
3492        return cls(
3493            meta=d.get('meta'),
3494            public_key=d.get('public_key'),
3495            rate_limit=d.get('rate_limit'),
3496        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3456    def __init__(
3457        self,
3458        meta=None,
3459        public_key=None,
3460        rate_limit=None,
3461    ):
3462        self.meta = meta if meta is not None else None
3463        '''
3464         Reserved for future use.
3465        '''
3466        self.public_key = public_key if public_key is not None else ''
3467        '''
3468         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3469         key format.
3470        '''
3471        self.rate_limit = rate_limit if rate_limit is not None else None
3472        '''
3473         Rate limit information.
3474        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3483    def to_dict(self):
3484        return {
3485            'meta': self.meta,
3486            'public_key': self.public_key,
3487            'rate_limit': self.rate_limit,
3488        }
@classmethod
def from_dict(cls, d)
3490    @classmethod
3491    def from_dict(cls, d):
3492        return cls(
3493            meta=d.get('meta'),
3494            public_key=d.get('public_key'),
3495            rate_limit=d.get('rate_limit'),
3496        )
class ControlPanelVerifyJWTResponse:
3499class ControlPanelVerifyJWTResponse:
3500    '''
3501         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3502    '''
3503    __slots__ = [
3504        'meta',
3505        'rate_limit',
3506        'valid',
3507    ]
3508
3509    def __init__(
3510        self,
3511        meta=None,
3512        rate_limit=None,
3513        valid=None,
3514    ):
3515        self.meta = meta if meta is not None else None
3516        '''
3517         Reserved for future use.
3518        '''
3519        self.rate_limit = rate_limit if rate_limit is not None else None
3520        '''
3521         Rate limit information.
3522        '''
3523        self.valid = valid if valid is not None else False
3524        '''
3525         Reports if the given token is valid.
3526        '''
3527
3528    def __repr__(self):
3529        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3530            'meta: ' + repr(self.meta) + ' ' +\
3531            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3532            'valid: ' + repr(self.valid) + ' ' +\
3533            '>'
3534
3535    def to_dict(self):
3536        return {
3537            'meta': self.meta,
3538            'rate_limit': self.rate_limit,
3539            'valid': self.valid,
3540        }
3541
3542    @classmethod
3543    def from_dict(cls, d):
3544        return cls(
3545            meta=d.get('meta'),
3546            rate_limit=d.get('rate_limit'),
3547            valid=d.get('valid'),
3548        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
3509    def __init__(
3510        self,
3511        meta=None,
3512        rate_limit=None,
3513        valid=None,
3514    ):
3515        self.meta = meta if meta is not None else None
3516        '''
3517         Reserved for future use.
3518        '''
3519        self.rate_limit = rate_limit if rate_limit is not None else None
3520        '''
3521         Rate limit information.
3522        '''
3523        self.valid = valid if valid is not None else False
3524        '''
3525         Reports if the given token is valid.
3526        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
3535    def to_dict(self):
3536        return {
3537            'meta': self.meta,
3538            'rate_limit': self.rate_limit,
3539            'valid': self.valid,
3540        }
@classmethod
def from_dict(cls, d)
3542    @classmethod
3543    def from_dict(cls, d):
3544        return cls(
3545            meta=d.get('meta'),
3546            rate_limit=d.get('rate_limit'),
3547            valid=d.get('valid'),
3548        )
class CreateResponseMetadata:
3551class CreateResponseMetadata:
3552    '''
3553         CreateResponseMetadata is reserved for future use.
3554    '''
3555    __slots__ = []
3556
3557    def __init__(self, ):
3558        pass
3559
3560    def __repr__(self):
3561        return '<sdm.CreateResponseMetadata ' + \
3562            '>'
3563
3564    def to_dict(self):
3565        return {}
3566
3567    @classmethod
3568    def from_dict(cls, d):
3569        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
3557    def __init__(self, ):
3558        pass
def to_dict(self)
3564    def to_dict(self):
3565        return {}
@classmethod
def from_dict(cls, d)
3567    @classmethod
3568    def from_dict(cls, d):
3569        return cls()
class DB2I:
3572class DB2I:
3573    __slots__ = [
3574        'bind_interface',
3575        'egress_filter',
3576        'healthy',
3577        'hostname',
3578        'id',
3579        'name',
3580        'password',
3581        'port',
3582        'port_override',
3583        'secret_store_id',
3584        'tags',
3585        'tls_required',
3586        'username',
3587    ]
3588
3589    def __init__(
3590        self,
3591        bind_interface=None,
3592        egress_filter=None,
3593        healthy=None,
3594        hostname=None,
3595        id=None,
3596        name=None,
3597        password=None,
3598        port=None,
3599        port_override=None,
3600        secret_store_id=None,
3601        tags=None,
3602        tls_required=None,
3603        username=None,
3604    ):
3605        self.bind_interface = bind_interface if bind_interface is not None else ''
3606        '''
3607         Bind interface
3608        '''
3609        self.egress_filter = egress_filter if egress_filter is not None else ''
3610        '''
3611         A filter applied to the routing logic to pin datasource to nodes.
3612        '''
3613        self.healthy = healthy if healthy is not None else False
3614        '''
3615         True if the datasource is reachable and the credentials are valid.
3616        '''
3617        self.hostname = hostname if hostname is not None else ''
3618        self.id = id if id is not None else ''
3619        '''
3620         Unique identifier of the Resource.
3621        '''
3622        self.name = name if name is not None else ''
3623        '''
3624         Unique human-readable name of the Resource.
3625        '''
3626        self.password = password if password is not None else ''
3627        self.port = port if port is not None else 0
3628        self.port_override = port_override if port_override is not None else 0
3629        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3630        '''
3631         ID of the secret store containing credentials for this resource, if any.
3632        '''
3633        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3634        '''
3635         Tags is a map of key, value pairs.
3636        '''
3637        self.tls_required = tls_required if tls_required is not None else False
3638        self.username = username if username is not None else ''
3639
3640    def __repr__(self):
3641        return '<sdm.DB2I ' + \
3642            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3643            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3644            'healthy: ' + repr(self.healthy) + ' ' +\
3645            'hostname: ' + repr(self.hostname) + ' ' +\
3646            'id: ' + repr(self.id) + ' ' +\
3647            'name: ' + repr(self.name) + ' ' +\
3648            'password: ' + repr(self.password) + ' ' +\
3649            'port: ' + repr(self.port) + ' ' +\
3650            'port_override: ' + repr(self.port_override) + ' ' +\
3651            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3652            'tags: ' + repr(self.tags) + ' ' +\
3653            'tls_required: ' + repr(self.tls_required) + ' ' +\
3654            'username: ' + repr(self.username) + ' ' +\
3655            '>'
3656
3657    def to_dict(self):
3658        return {
3659            'bind_interface': self.bind_interface,
3660            'egress_filter': self.egress_filter,
3661            'healthy': self.healthy,
3662            'hostname': self.hostname,
3663            'id': self.id,
3664            'name': self.name,
3665            'password': self.password,
3666            'port': self.port,
3667            'port_override': self.port_override,
3668            'secret_store_id': self.secret_store_id,
3669            'tags': self.tags,
3670            'tls_required': self.tls_required,
3671            'username': self.username,
3672        }
3673
3674    @classmethod
3675    def from_dict(cls, d):
3676        return cls(
3677            bind_interface=d.get('bind_interface'),
3678            egress_filter=d.get('egress_filter'),
3679            healthy=d.get('healthy'),
3680            hostname=d.get('hostname'),
3681            id=d.get('id'),
3682            name=d.get('name'),
3683            password=d.get('password'),
3684            port=d.get('port'),
3685            port_override=d.get('port_override'),
3686            secret_store_id=d.get('secret_store_id'),
3687            tags=d.get('tags'),
3688            tls_required=d.get('tls_required'),
3689            username=d.get('username'),
3690        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3589    def __init__(
3590        self,
3591        bind_interface=None,
3592        egress_filter=None,
3593        healthy=None,
3594        hostname=None,
3595        id=None,
3596        name=None,
3597        password=None,
3598        port=None,
3599        port_override=None,
3600        secret_store_id=None,
3601        tags=None,
3602        tls_required=None,
3603        username=None,
3604    ):
3605        self.bind_interface = bind_interface if bind_interface is not None else ''
3606        '''
3607         Bind interface
3608        '''
3609        self.egress_filter = egress_filter if egress_filter is not None else ''
3610        '''
3611         A filter applied to the routing logic to pin datasource to nodes.
3612        '''
3613        self.healthy = healthy if healthy is not None else False
3614        '''
3615         True if the datasource is reachable and the credentials are valid.
3616        '''
3617        self.hostname = hostname if hostname is not None else ''
3618        self.id = id if id is not None else ''
3619        '''
3620         Unique identifier of the Resource.
3621        '''
3622        self.name = name if name is not None else ''
3623        '''
3624         Unique human-readable name of the Resource.
3625        '''
3626        self.password = password if password is not None else ''
3627        self.port = port if port is not None else 0
3628        self.port_override = port_override if port_override is not None else 0
3629        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3630        '''
3631         ID of the secret store containing credentials for this resource, if any.
3632        '''
3633        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3634        '''
3635         Tags is a map of key, value pairs.
3636        '''
3637        self.tls_required = tls_required if tls_required is not None else False
3638        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3657    def to_dict(self):
3658        return {
3659            'bind_interface': self.bind_interface,
3660            'egress_filter': self.egress_filter,
3661            'healthy': self.healthy,
3662            'hostname': self.hostname,
3663            'id': self.id,
3664            'name': self.name,
3665            'password': self.password,
3666            'port': self.port,
3667            'port_override': self.port_override,
3668            'secret_store_id': self.secret_store_id,
3669            'tags': self.tags,
3670            'tls_required': self.tls_required,
3671            'username': self.username,
3672        }
@classmethod
def from_dict(cls, d)
3674    @classmethod
3675    def from_dict(cls, d):
3676        return cls(
3677            bind_interface=d.get('bind_interface'),
3678            egress_filter=d.get('egress_filter'),
3679            healthy=d.get('healthy'),
3680            hostname=d.get('hostname'),
3681            id=d.get('id'),
3682            name=d.get('name'),
3683            password=d.get('password'),
3684            port=d.get('port'),
3685            port_override=d.get('port_override'),
3686            secret_store_id=d.get('secret_store_id'),
3687            tags=d.get('tags'),
3688            tls_required=d.get('tls_required'),
3689            username=d.get('username'),
3690        )
class DB2LUW:
3693class DB2LUW:
3694    __slots__ = [
3695        'bind_interface',
3696        'database',
3697        'egress_filter',
3698        'healthy',
3699        'hostname',
3700        'id',
3701        'name',
3702        'password',
3703        'port',
3704        'port_override',
3705        'secret_store_id',
3706        'tags',
3707        'username',
3708    ]
3709
3710    def __init__(
3711        self,
3712        bind_interface=None,
3713        database=None,
3714        egress_filter=None,
3715        healthy=None,
3716        hostname=None,
3717        id=None,
3718        name=None,
3719        password=None,
3720        port=None,
3721        port_override=None,
3722        secret_store_id=None,
3723        tags=None,
3724        username=None,
3725    ):
3726        self.bind_interface = bind_interface if bind_interface is not None else ''
3727        '''
3728         Bind interface
3729        '''
3730        self.database = database if database is not None else ''
3731        self.egress_filter = egress_filter if egress_filter is not None else ''
3732        '''
3733         A filter applied to the routing logic to pin datasource to nodes.
3734        '''
3735        self.healthy = healthy if healthy is not None else False
3736        '''
3737         True if the datasource is reachable and the credentials are valid.
3738        '''
3739        self.hostname = hostname if hostname is not None else ''
3740        self.id = id if id is not None else ''
3741        '''
3742         Unique identifier of the Resource.
3743        '''
3744        self.name = name if name is not None else ''
3745        '''
3746         Unique human-readable name of the Resource.
3747        '''
3748        self.password = password if password is not None else ''
3749        self.port = port if port is not None else 0
3750        self.port_override = port_override if port_override is not None else 0
3751        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3752        '''
3753         ID of the secret store containing credentials for this resource, if any.
3754        '''
3755        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3756        '''
3757         Tags is a map of key, value pairs.
3758        '''
3759        self.username = username if username is not None else ''
3760
3761    def __repr__(self):
3762        return '<sdm.DB2LUW ' + \
3763            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3764            'database: ' + repr(self.database) + ' ' +\
3765            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3766            'healthy: ' + repr(self.healthy) + ' ' +\
3767            'hostname: ' + repr(self.hostname) + ' ' +\
3768            'id: ' + repr(self.id) + ' ' +\
3769            'name: ' + repr(self.name) + ' ' +\
3770            'password: ' + repr(self.password) + ' ' +\
3771            'port: ' + repr(self.port) + ' ' +\
3772            'port_override: ' + repr(self.port_override) + ' ' +\
3773            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3774            'tags: ' + repr(self.tags) + ' ' +\
3775            'username: ' + repr(self.username) + ' ' +\
3776            '>'
3777
3778    def to_dict(self):
3779        return {
3780            'bind_interface': self.bind_interface,
3781            'database': self.database,
3782            'egress_filter': self.egress_filter,
3783            'healthy': self.healthy,
3784            'hostname': self.hostname,
3785            'id': self.id,
3786            'name': self.name,
3787            'password': self.password,
3788            'port': self.port,
3789            'port_override': self.port_override,
3790            'secret_store_id': self.secret_store_id,
3791            'tags': self.tags,
3792            'username': self.username,
3793        }
3794
3795    @classmethod
3796    def from_dict(cls, d):
3797        return cls(
3798            bind_interface=d.get('bind_interface'),
3799            database=d.get('database'),
3800            egress_filter=d.get('egress_filter'),
3801            healthy=d.get('healthy'),
3802            hostname=d.get('hostname'),
3803            id=d.get('id'),
3804            name=d.get('name'),
3805            password=d.get('password'),
3806            port=d.get('port'),
3807            port_override=d.get('port_override'),
3808            secret_store_id=d.get('secret_store_id'),
3809            tags=d.get('tags'),
3810            username=d.get('username'),
3811        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3710    def __init__(
3711        self,
3712        bind_interface=None,
3713        database=None,
3714        egress_filter=None,
3715        healthy=None,
3716        hostname=None,
3717        id=None,
3718        name=None,
3719        password=None,
3720        port=None,
3721        port_override=None,
3722        secret_store_id=None,
3723        tags=None,
3724        username=None,
3725    ):
3726        self.bind_interface = bind_interface if bind_interface is not None else ''
3727        '''
3728         Bind interface
3729        '''
3730        self.database = database if database is not None else ''
3731        self.egress_filter = egress_filter if egress_filter is not None else ''
3732        '''
3733         A filter applied to the routing logic to pin datasource to nodes.
3734        '''
3735        self.healthy = healthy if healthy is not None else False
3736        '''
3737         True if the datasource is reachable and the credentials are valid.
3738        '''
3739        self.hostname = hostname if hostname is not None else ''
3740        self.id = id if id is not None else ''
3741        '''
3742         Unique identifier of the Resource.
3743        '''
3744        self.name = name if name is not None else ''
3745        '''
3746         Unique human-readable name of the Resource.
3747        '''
3748        self.password = password if password is not None else ''
3749        self.port = port if port is not None else 0
3750        self.port_override = port_override if port_override is not None else 0
3751        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3752        '''
3753         ID of the secret store containing credentials for this resource, if any.
3754        '''
3755        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3756        '''
3757         Tags is a map of key, value pairs.
3758        '''
3759        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3778    def to_dict(self):
3779        return {
3780            'bind_interface': self.bind_interface,
3781            'database': self.database,
3782            'egress_filter': self.egress_filter,
3783            'healthy': self.healthy,
3784            'hostname': self.hostname,
3785            'id': self.id,
3786            'name': self.name,
3787            'password': self.password,
3788            'port': self.port,
3789            'port_override': self.port_override,
3790            'secret_store_id': self.secret_store_id,
3791            'tags': self.tags,
3792            'username': self.username,
3793        }
@classmethod
def from_dict(cls, d)
3795    @classmethod
3796    def from_dict(cls, d):
3797        return cls(
3798            bind_interface=d.get('bind_interface'),
3799            database=d.get('database'),
3800            egress_filter=d.get('egress_filter'),
3801            healthy=d.get('healthy'),
3802            hostname=d.get('hostname'),
3803            id=d.get('id'),
3804            name=d.get('name'),
3805            password=d.get('password'),
3806            port=d.get('port'),
3807            port_override=d.get('port_override'),
3808            secret_store_id=d.get('secret_store_id'),
3809            tags=d.get('tags'),
3810            username=d.get('username'),
3811        )
class DeleteResponseMetadata:
3814class DeleteResponseMetadata:
3815    '''
3816         DeleteResponseMetadata is reserved for future use.
3817    '''
3818    __slots__ = []
3819
3820    def __init__(self, ):
3821        pass
3822
3823    def __repr__(self):
3824        return '<sdm.DeleteResponseMetadata ' + \
3825            '>'
3826
3827    def to_dict(self):
3828        return {}
3829
3830    @classmethod
3831    def from_dict(cls, d):
3832        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
3820    def __init__(self, ):
3821        pass
def to_dict(self)
3827    def to_dict(self):
3828        return {}
@classmethod
def from_dict(cls, d)
3830    @classmethod
3831    def from_dict(cls, d):
3832        return cls()
class DelineaStore:
3835class DelineaStore:
3836    '''
3837    DelineaStore is currently unstable, and its API may change, or it may be removed,
3838    without a major version bump.
3839    '''
3840    __slots__ = [
3841        'id',
3842        'name',
3843        'server_url',
3844        'tags',
3845        'tenant_name',
3846    ]
3847
3848    def __init__(
3849        self,
3850        id=None,
3851        name=None,
3852        server_url=None,
3853        tags=None,
3854        tenant_name=None,
3855    ):
3856        self.id = id if id is not None else ''
3857        '''
3858         Unique identifier of the SecretStore.
3859        '''
3860        self.name = name if name is not None else ''
3861        '''
3862         Unique human-readable name of the SecretStore.
3863        '''
3864        self.server_url = server_url if server_url is not None else ''
3865        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3866        '''
3867         Tags is a map of key, value pairs.
3868        '''
3869        self.tenant_name = tenant_name if tenant_name is not None else ''
3870
3871    def __repr__(self):
3872        return '<sdm.DelineaStore ' + \
3873            'id: ' + repr(self.id) + ' ' +\
3874            'name: ' + repr(self.name) + ' ' +\
3875            'server_url: ' + repr(self.server_url) + ' ' +\
3876            'tags: ' + repr(self.tags) + ' ' +\
3877            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
3878            '>'
3879
3880    def to_dict(self):
3881        return {
3882            'id': self.id,
3883            'name': self.name,
3884            'server_url': self.server_url,
3885            'tags': self.tags,
3886            'tenant_name': self.tenant_name,
3887        }
3888
3889    @classmethod
3890    def from_dict(cls, d):
3891        return cls(
3892            id=d.get('id'),
3893            name=d.get('name'),
3894            server_url=d.get('server_url'),
3895            tags=d.get('tags'),
3896            tenant_name=d.get('tenant_name'),
3897        )

DelineaStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

DelineaStore(id=None, name=None, server_url=None, tags=None, tenant_name=None)
3848    def __init__(
3849        self,
3850        id=None,
3851        name=None,
3852        server_url=None,
3853        tags=None,
3854        tenant_name=None,
3855    ):
3856        self.id = id if id is not None else ''
3857        '''
3858         Unique identifier of the SecretStore.
3859        '''
3860        self.name = name if name is not None else ''
3861        '''
3862         Unique human-readable name of the SecretStore.
3863        '''
3864        self.server_url = server_url if server_url is not None else ''
3865        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3866        '''
3867         Tags is a map of key, value pairs.
3868        '''
3869        self.tenant_name = tenant_name if tenant_name is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

server_url
tags

Tags is a map of key, value pairs.

tenant_name
def to_dict(self)
3880    def to_dict(self):
3881        return {
3882            'id': self.id,
3883            'name': self.name,
3884            'server_url': self.server_url,
3885            'tags': self.tags,
3886            'tenant_name': self.tenant_name,
3887        }
@classmethod
def from_dict(cls, d)
3889    @classmethod
3890    def from_dict(cls, d):
3891        return cls(
3892            id=d.get('id'),
3893            name=d.get('name'),
3894            server_url=d.get('server_url'),
3895            tags=d.get('tags'),
3896            tenant_name=d.get('tenant_name'),
3897        )
class DocumentDBHost:
3900class DocumentDBHost:
3901    __slots__ = [
3902        'auth_database',
3903        'bind_interface',
3904        'egress_filter',
3905        'healthy',
3906        'hostname',
3907        'id',
3908        'name',
3909        'password',
3910        'port',
3911        'port_override',
3912        'secret_store_id',
3913        'tags',
3914        'username',
3915    ]
3916
3917    def __init__(
3918        self,
3919        auth_database=None,
3920        bind_interface=None,
3921        egress_filter=None,
3922        healthy=None,
3923        hostname=None,
3924        id=None,
3925        name=None,
3926        password=None,
3927        port=None,
3928        port_override=None,
3929        secret_store_id=None,
3930        tags=None,
3931        username=None,
3932    ):
3933        self.auth_database = auth_database if auth_database is not None else ''
3934        self.bind_interface = bind_interface if bind_interface is not None else ''
3935        '''
3936         Bind interface
3937        '''
3938        self.egress_filter = egress_filter if egress_filter is not None else ''
3939        '''
3940         A filter applied to the routing logic to pin datasource to nodes.
3941        '''
3942        self.healthy = healthy if healthy is not None else False
3943        '''
3944         True if the datasource is reachable and the credentials are valid.
3945        '''
3946        self.hostname = hostname if hostname is not None else ''
3947        self.id = id if id is not None else ''
3948        '''
3949         Unique identifier of the Resource.
3950        '''
3951        self.name = name if name is not None else ''
3952        '''
3953         Unique human-readable name of the Resource.
3954        '''
3955        self.password = password if password is not None else ''
3956        self.port = port if port is not None else 0
3957        self.port_override = port_override if port_override is not None else 0
3958        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3959        '''
3960         ID of the secret store containing credentials for this resource, if any.
3961        '''
3962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3963        '''
3964         Tags is a map of key, value pairs.
3965        '''
3966        self.username = username if username is not None else ''
3967
3968    def __repr__(self):
3969        return '<sdm.DocumentDBHost ' + \
3970            'auth_database: ' + repr(self.auth_database) + ' ' +\
3971            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3972            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3973            'healthy: ' + repr(self.healthy) + ' ' +\
3974            'hostname: ' + repr(self.hostname) + ' ' +\
3975            'id: ' + repr(self.id) + ' ' +\
3976            'name: ' + repr(self.name) + ' ' +\
3977            'password: ' + repr(self.password) + ' ' +\
3978            'port: ' + repr(self.port) + ' ' +\
3979            'port_override: ' + repr(self.port_override) + ' ' +\
3980            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3981            'tags: ' + repr(self.tags) + ' ' +\
3982            'username: ' + repr(self.username) + ' ' +\
3983            '>'
3984
3985    def to_dict(self):
3986        return {
3987            'auth_database': self.auth_database,
3988            'bind_interface': self.bind_interface,
3989            'egress_filter': self.egress_filter,
3990            'healthy': self.healthy,
3991            'hostname': self.hostname,
3992            'id': self.id,
3993            'name': self.name,
3994            'password': self.password,
3995            'port': self.port,
3996            'port_override': self.port_override,
3997            'secret_store_id': self.secret_store_id,
3998            'tags': self.tags,
3999            'username': self.username,
4000        }
4001
4002    @classmethod
4003    def from_dict(cls, d):
4004        return cls(
4005            auth_database=d.get('auth_database'),
4006            bind_interface=d.get('bind_interface'),
4007            egress_filter=d.get('egress_filter'),
4008            healthy=d.get('healthy'),
4009            hostname=d.get('hostname'),
4010            id=d.get('id'),
4011            name=d.get('name'),
4012            password=d.get('password'),
4013            port=d.get('port'),
4014            port_override=d.get('port_override'),
4015            secret_store_id=d.get('secret_store_id'),
4016            tags=d.get('tags'),
4017            username=d.get('username'),
4018        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3917    def __init__(
3918        self,
3919        auth_database=None,
3920        bind_interface=None,
3921        egress_filter=None,
3922        healthy=None,
3923        hostname=None,
3924        id=None,
3925        name=None,
3926        password=None,
3927        port=None,
3928        port_override=None,
3929        secret_store_id=None,
3930        tags=None,
3931        username=None,
3932    ):
3933        self.auth_database = auth_database if auth_database is not None else ''
3934        self.bind_interface = bind_interface if bind_interface is not None else ''
3935        '''
3936         Bind interface
3937        '''
3938        self.egress_filter = egress_filter if egress_filter is not None else ''
3939        '''
3940         A filter applied to the routing logic to pin datasource to nodes.
3941        '''
3942        self.healthy = healthy if healthy is not None else False
3943        '''
3944         True if the datasource is reachable and the credentials are valid.
3945        '''
3946        self.hostname = hostname if hostname is not None else ''
3947        self.id = id if id is not None else ''
3948        '''
3949         Unique identifier of the Resource.
3950        '''
3951        self.name = name if name is not None else ''
3952        '''
3953         Unique human-readable name of the Resource.
3954        '''
3955        self.password = password if password is not None else ''
3956        self.port = port if port is not None else 0
3957        self.port_override = port_override if port_override is not None else 0
3958        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3959        '''
3960         ID of the secret store containing credentials for this resource, if any.
3961        '''
3962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3963        '''
3964         Tags is a map of key, value pairs.
3965        '''
3966        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3985    def to_dict(self):
3986        return {
3987            'auth_database': self.auth_database,
3988            'bind_interface': self.bind_interface,
3989            'egress_filter': self.egress_filter,
3990            'healthy': self.healthy,
3991            'hostname': self.hostname,
3992            'id': self.id,
3993            'name': self.name,
3994            'password': self.password,
3995            'port': self.port,
3996            'port_override': self.port_override,
3997            'secret_store_id': self.secret_store_id,
3998            'tags': self.tags,
3999            'username': self.username,
4000        }
@classmethod
def from_dict(cls, d)
4002    @classmethod
4003    def from_dict(cls, d):
4004        return cls(
4005            auth_database=d.get('auth_database'),
4006            bind_interface=d.get('bind_interface'),
4007            egress_filter=d.get('egress_filter'),
4008            healthy=d.get('healthy'),
4009            hostname=d.get('hostname'),
4010            id=d.get('id'),
4011            name=d.get('name'),
4012            password=d.get('password'),
4013            port=d.get('port'),
4014            port_override=d.get('port_override'),
4015            secret_store_id=d.get('secret_store_id'),
4016            tags=d.get('tags'),
4017            username=d.get('username'),
4018        )
class DocumentDBReplicaSet:
4021class DocumentDBReplicaSet:
4022    __slots__ = [
4023        'auth_database',
4024        'bind_interface',
4025        'connect_to_replica',
4026        'egress_filter',
4027        'healthy',
4028        'hostname',
4029        'id',
4030        'name',
4031        'password',
4032        'port_override',
4033        'replica_set',
4034        'secret_store_id',
4035        'tags',
4036        'username',
4037    ]
4038
4039    def __init__(
4040        self,
4041        auth_database=None,
4042        bind_interface=None,
4043        connect_to_replica=None,
4044        egress_filter=None,
4045        healthy=None,
4046        hostname=None,
4047        id=None,
4048        name=None,
4049        password=None,
4050        port_override=None,
4051        replica_set=None,
4052        secret_store_id=None,
4053        tags=None,
4054        username=None,
4055    ):
4056        self.auth_database = auth_database if auth_database is not None else ''
4057        self.bind_interface = bind_interface if bind_interface is not None else ''
4058        '''
4059         Bind interface
4060        '''
4061        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4062        self.egress_filter = egress_filter if egress_filter is not None else ''
4063        '''
4064         A filter applied to the routing logic to pin datasource to nodes.
4065        '''
4066        self.healthy = healthy if healthy is not None else False
4067        '''
4068         True if the datasource is reachable and the credentials are valid.
4069        '''
4070        self.hostname = hostname if hostname is not None else ''
4071        '''
4072         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4073        '''
4074        self.id = id if id is not None else ''
4075        '''
4076         Unique identifier of the Resource.
4077        '''
4078        self.name = name if name is not None else ''
4079        '''
4080         Unique human-readable name of the Resource.
4081        '''
4082        self.password = password if password is not None else ''
4083        self.port_override = port_override if port_override is not None else 0
4084        self.replica_set = replica_set if replica_set is not None else ''
4085        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4086        '''
4087         ID of the secret store containing credentials for this resource, if any.
4088        '''
4089        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4090        '''
4091         Tags is a map of key, value pairs.
4092        '''
4093        self.username = username if username is not None else ''
4094
4095    def __repr__(self):
4096        return '<sdm.DocumentDBReplicaSet ' + \
4097            'auth_database: ' + repr(self.auth_database) + ' ' +\
4098            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4099            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4100            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4101            'healthy: ' + repr(self.healthy) + ' ' +\
4102            'hostname: ' + repr(self.hostname) + ' ' +\
4103            'id: ' + repr(self.id) + ' ' +\
4104            'name: ' + repr(self.name) + ' ' +\
4105            'password: ' + repr(self.password) + ' ' +\
4106            'port_override: ' + repr(self.port_override) + ' ' +\
4107            'replica_set: ' + repr(self.replica_set) + ' ' +\
4108            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4109            'tags: ' + repr(self.tags) + ' ' +\
4110            'username: ' + repr(self.username) + ' ' +\
4111            '>'
4112
4113    def to_dict(self):
4114        return {
4115            'auth_database': self.auth_database,
4116            'bind_interface': self.bind_interface,
4117            'connect_to_replica': self.connect_to_replica,
4118            'egress_filter': self.egress_filter,
4119            'healthy': self.healthy,
4120            'hostname': self.hostname,
4121            'id': self.id,
4122            'name': self.name,
4123            'password': self.password,
4124            'port_override': self.port_override,
4125            'replica_set': self.replica_set,
4126            'secret_store_id': self.secret_store_id,
4127            'tags': self.tags,
4128            'username': self.username,
4129        }
4130
4131    @classmethod
4132    def from_dict(cls, d):
4133        return cls(
4134            auth_database=d.get('auth_database'),
4135            bind_interface=d.get('bind_interface'),
4136            connect_to_replica=d.get('connect_to_replica'),
4137            egress_filter=d.get('egress_filter'),
4138            healthy=d.get('healthy'),
4139            hostname=d.get('hostname'),
4140            id=d.get('id'),
4141            name=d.get('name'),
4142            password=d.get('password'),
4143            port_override=d.get('port_override'),
4144            replica_set=d.get('replica_set'),
4145            secret_store_id=d.get('secret_store_id'),
4146            tags=d.get('tags'),
4147            username=d.get('username'),
4148        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4039    def __init__(
4040        self,
4041        auth_database=None,
4042        bind_interface=None,
4043        connect_to_replica=None,
4044        egress_filter=None,
4045        healthy=None,
4046        hostname=None,
4047        id=None,
4048        name=None,
4049        password=None,
4050        port_override=None,
4051        replica_set=None,
4052        secret_store_id=None,
4053        tags=None,
4054        username=None,
4055    ):
4056        self.auth_database = auth_database if auth_database is not None else ''
4057        self.bind_interface = bind_interface if bind_interface is not None else ''
4058        '''
4059         Bind interface
4060        '''
4061        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4062        self.egress_filter = egress_filter if egress_filter is not None else ''
4063        '''
4064         A filter applied to the routing logic to pin datasource to nodes.
4065        '''
4066        self.healthy = healthy if healthy is not None else False
4067        '''
4068         True if the datasource is reachable and the credentials are valid.
4069        '''
4070        self.hostname = hostname if hostname is not None else ''
4071        '''
4072         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4073        '''
4074        self.id = id if id is not None else ''
4075        '''
4076         Unique identifier of the Resource.
4077        '''
4078        self.name = name if name is not None else ''
4079        '''
4080         Unique human-readable name of the Resource.
4081        '''
4082        self.password = password if password is not None else ''
4083        self.port_override = port_override if port_override is not None else 0
4084        self.replica_set = replica_set if replica_set is not None else ''
4085        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4086        '''
4087         ID of the secret store containing credentials for this resource, if any.
4088        '''
4089        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4090        '''
4091         Tags is a map of key, value pairs.
4092        '''
4093        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4113    def to_dict(self):
4114        return {
4115            'auth_database': self.auth_database,
4116            'bind_interface': self.bind_interface,
4117            'connect_to_replica': self.connect_to_replica,
4118            'egress_filter': self.egress_filter,
4119            'healthy': self.healthy,
4120            'hostname': self.hostname,
4121            'id': self.id,
4122            'name': self.name,
4123            'password': self.password,
4124            'port_override': self.port_override,
4125            'replica_set': self.replica_set,
4126            'secret_store_id': self.secret_store_id,
4127            'tags': self.tags,
4128            'username': self.username,
4129        }
@classmethod
def from_dict(cls, d)
4131    @classmethod
4132    def from_dict(cls, d):
4133        return cls(
4134            auth_database=d.get('auth_database'),
4135            bind_interface=d.get('bind_interface'),
4136            connect_to_replica=d.get('connect_to_replica'),
4137            egress_filter=d.get('egress_filter'),
4138            healthy=d.get('healthy'),
4139            hostname=d.get('hostname'),
4140            id=d.get('id'),
4141            name=d.get('name'),
4142            password=d.get('password'),
4143            port_override=d.get('port_override'),
4144            replica_set=d.get('replica_set'),
4145            secret_store_id=d.get('secret_store_id'),
4146            tags=d.get('tags'),
4147            username=d.get('username'),
4148        )
class Druid:
4151class Druid:
4152    __slots__ = [
4153        'bind_interface',
4154        'egress_filter',
4155        'healthy',
4156        'hostname',
4157        'id',
4158        'name',
4159        'password',
4160        'port',
4161        'port_override',
4162        'secret_store_id',
4163        'tags',
4164        'username',
4165    ]
4166
4167    def __init__(
4168        self,
4169        bind_interface=None,
4170        egress_filter=None,
4171        healthy=None,
4172        hostname=None,
4173        id=None,
4174        name=None,
4175        password=None,
4176        port=None,
4177        port_override=None,
4178        secret_store_id=None,
4179        tags=None,
4180        username=None,
4181    ):
4182        self.bind_interface = bind_interface if bind_interface is not None else ''
4183        '''
4184         Bind interface
4185        '''
4186        self.egress_filter = egress_filter if egress_filter is not None else ''
4187        '''
4188         A filter applied to the routing logic to pin datasource to nodes.
4189        '''
4190        self.healthy = healthy if healthy is not None else False
4191        '''
4192         True if the datasource is reachable and the credentials are valid.
4193        '''
4194        self.hostname = hostname if hostname is not None else ''
4195        self.id = id if id is not None else ''
4196        '''
4197         Unique identifier of the Resource.
4198        '''
4199        self.name = name if name is not None else ''
4200        '''
4201         Unique human-readable name of the Resource.
4202        '''
4203        self.password = password if password is not None else ''
4204        self.port = port if port is not None else 0
4205        self.port_override = port_override if port_override is not None else 0
4206        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4207        '''
4208         ID of the secret store containing credentials for this resource, if any.
4209        '''
4210        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4211        '''
4212         Tags is a map of key, value pairs.
4213        '''
4214        self.username = username if username is not None else ''
4215
4216    def __repr__(self):
4217        return '<sdm.Druid ' + \
4218            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4219            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4220            'healthy: ' + repr(self.healthy) + ' ' +\
4221            'hostname: ' + repr(self.hostname) + ' ' +\
4222            'id: ' + repr(self.id) + ' ' +\
4223            'name: ' + repr(self.name) + ' ' +\
4224            'password: ' + repr(self.password) + ' ' +\
4225            'port: ' + repr(self.port) + ' ' +\
4226            'port_override: ' + repr(self.port_override) + ' ' +\
4227            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4228            'tags: ' + repr(self.tags) + ' ' +\
4229            'username: ' + repr(self.username) + ' ' +\
4230            '>'
4231
4232    def to_dict(self):
4233        return {
4234            'bind_interface': self.bind_interface,
4235            'egress_filter': self.egress_filter,
4236            'healthy': self.healthy,
4237            'hostname': self.hostname,
4238            'id': self.id,
4239            'name': self.name,
4240            'password': self.password,
4241            'port': self.port,
4242            'port_override': self.port_override,
4243            'secret_store_id': self.secret_store_id,
4244            'tags': self.tags,
4245            'username': self.username,
4246        }
4247
4248    @classmethod
4249    def from_dict(cls, d):
4250        return cls(
4251            bind_interface=d.get('bind_interface'),
4252            egress_filter=d.get('egress_filter'),
4253            healthy=d.get('healthy'),
4254            hostname=d.get('hostname'),
4255            id=d.get('id'),
4256            name=d.get('name'),
4257            password=d.get('password'),
4258            port=d.get('port'),
4259            port_override=d.get('port_override'),
4260            secret_store_id=d.get('secret_store_id'),
4261            tags=d.get('tags'),
4262            username=d.get('username'),
4263        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4167    def __init__(
4168        self,
4169        bind_interface=None,
4170        egress_filter=None,
4171        healthy=None,
4172        hostname=None,
4173        id=None,
4174        name=None,
4175        password=None,
4176        port=None,
4177        port_override=None,
4178        secret_store_id=None,
4179        tags=None,
4180        username=None,
4181    ):
4182        self.bind_interface = bind_interface if bind_interface is not None else ''
4183        '''
4184         Bind interface
4185        '''
4186        self.egress_filter = egress_filter if egress_filter is not None else ''
4187        '''
4188         A filter applied to the routing logic to pin datasource to nodes.
4189        '''
4190        self.healthy = healthy if healthy is not None else False
4191        '''
4192         True if the datasource is reachable and the credentials are valid.
4193        '''
4194        self.hostname = hostname if hostname is not None else ''
4195        self.id = id if id is not None else ''
4196        '''
4197         Unique identifier of the Resource.
4198        '''
4199        self.name = name if name is not None else ''
4200        '''
4201         Unique human-readable name of the Resource.
4202        '''
4203        self.password = password if password is not None else ''
4204        self.port = port if port is not None else 0
4205        self.port_override = port_override if port_override is not None else 0
4206        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4207        '''
4208         ID of the secret store containing credentials for this resource, if any.
4209        '''
4210        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4211        '''
4212         Tags is a map of key, value pairs.
4213        '''
4214        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4232    def to_dict(self):
4233        return {
4234            'bind_interface': self.bind_interface,
4235            'egress_filter': self.egress_filter,
4236            'healthy': self.healthy,
4237            'hostname': self.hostname,
4238            'id': self.id,
4239            'name': self.name,
4240            'password': self.password,
4241            'port': self.port,
4242            'port_override': self.port_override,
4243            'secret_store_id': self.secret_store_id,
4244            'tags': self.tags,
4245            'username': self.username,
4246        }
@classmethod
def from_dict(cls, d)
4248    @classmethod
4249    def from_dict(cls, d):
4250        return cls(
4251            bind_interface=d.get('bind_interface'),
4252            egress_filter=d.get('egress_filter'),
4253            healthy=d.get('healthy'),
4254            hostname=d.get('hostname'),
4255            id=d.get('id'),
4256            name=d.get('name'),
4257            password=d.get('password'),
4258            port=d.get('port'),
4259            port_override=d.get('port_override'),
4260            secret_store_id=d.get('secret_store_id'),
4261            tags=d.get('tags'),
4262            username=d.get('username'),
4263        )
class DynamoDB:
4266class DynamoDB:
4267    __slots__ = [
4268        'access_key',
4269        'bind_interface',
4270        'egress_filter',
4271        'endpoint',
4272        'healthy',
4273        'id',
4274        'name',
4275        'port_override',
4276        'region',
4277        'role_arn',
4278        'role_external_id',
4279        'secret_access_key',
4280        'secret_store_id',
4281        'tags',
4282    ]
4283
4284    def __init__(
4285        self,
4286        access_key=None,
4287        bind_interface=None,
4288        egress_filter=None,
4289        endpoint=None,
4290        healthy=None,
4291        id=None,
4292        name=None,
4293        port_override=None,
4294        region=None,
4295        role_arn=None,
4296        role_external_id=None,
4297        secret_access_key=None,
4298        secret_store_id=None,
4299        tags=None,
4300    ):
4301        self.access_key = access_key if access_key is not None else ''
4302        self.bind_interface = bind_interface if bind_interface is not None else ''
4303        '''
4304         Bind interface
4305        '''
4306        self.egress_filter = egress_filter if egress_filter is not None else ''
4307        '''
4308         A filter applied to the routing logic to pin datasource to nodes.
4309        '''
4310        self.endpoint = endpoint if endpoint is not None else ''
4311        self.healthy = healthy if healthy is not None else False
4312        '''
4313         True if the datasource is reachable and the credentials are valid.
4314        '''
4315        self.id = id if id is not None else ''
4316        '''
4317         Unique identifier of the Resource.
4318        '''
4319        self.name = name if name is not None else ''
4320        '''
4321         Unique human-readable name of the Resource.
4322        '''
4323        self.port_override = port_override if port_override is not None else 0
4324        self.region = region if region is not None else ''
4325        self.role_arn = role_arn if role_arn is not None else ''
4326        self.role_external_id = role_external_id if role_external_id is not None else ''
4327        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4328        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4329        '''
4330         ID of the secret store containing credentials for this resource, if any.
4331        '''
4332        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4333        '''
4334         Tags is a map of key, value pairs.
4335        '''
4336
4337    def __repr__(self):
4338        return '<sdm.DynamoDB ' + \
4339            'access_key: ' + repr(self.access_key) + ' ' +\
4340            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4341            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4342            'endpoint: ' + repr(self.endpoint) + ' ' +\
4343            'healthy: ' + repr(self.healthy) + ' ' +\
4344            'id: ' + repr(self.id) + ' ' +\
4345            'name: ' + repr(self.name) + ' ' +\
4346            'port_override: ' + repr(self.port_override) + ' ' +\
4347            'region: ' + repr(self.region) + ' ' +\
4348            'role_arn: ' + repr(self.role_arn) + ' ' +\
4349            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4350            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4351            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4352            'tags: ' + repr(self.tags) + ' ' +\
4353            '>'
4354
4355    def to_dict(self):
4356        return {
4357            'access_key': self.access_key,
4358            'bind_interface': self.bind_interface,
4359            'egress_filter': self.egress_filter,
4360            'endpoint': self.endpoint,
4361            'healthy': self.healthy,
4362            'id': self.id,
4363            'name': self.name,
4364            'port_override': self.port_override,
4365            'region': self.region,
4366            'role_arn': self.role_arn,
4367            'role_external_id': self.role_external_id,
4368            'secret_access_key': self.secret_access_key,
4369            'secret_store_id': self.secret_store_id,
4370            'tags': self.tags,
4371        }
4372
4373    @classmethod
4374    def from_dict(cls, d):
4375        return cls(
4376            access_key=d.get('access_key'),
4377            bind_interface=d.get('bind_interface'),
4378            egress_filter=d.get('egress_filter'),
4379            endpoint=d.get('endpoint'),
4380            healthy=d.get('healthy'),
4381            id=d.get('id'),
4382            name=d.get('name'),
4383            port_override=d.get('port_override'),
4384            region=d.get('region'),
4385            role_arn=d.get('role_arn'),
4386            role_external_id=d.get('role_external_id'),
4387            secret_access_key=d.get('secret_access_key'),
4388            secret_store_id=d.get('secret_store_id'),
4389            tags=d.get('tags'),
4390        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4284    def __init__(
4285        self,
4286        access_key=None,
4287        bind_interface=None,
4288        egress_filter=None,
4289        endpoint=None,
4290        healthy=None,
4291        id=None,
4292        name=None,
4293        port_override=None,
4294        region=None,
4295        role_arn=None,
4296        role_external_id=None,
4297        secret_access_key=None,
4298        secret_store_id=None,
4299        tags=None,
4300    ):
4301        self.access_key = access_key if access_key is not None else ''
4302        self.bind_interface = bind_interface if bind_interface is not None else ''
4303        '''
4304         Bind interface
4305        '''
4306        self.egress_filter = egress_filter if egress_filter is not None else ''
4307        '''
4308         A filter applied to the routing logic to pin datasource to nodes.
4309        '''
4310        self.endpoint = endpoint if endpoint is not None else ''
4311        self.healthy = healthy if healthy is not None else False
4312        '''
4313         True if the datasource is reachable and the credentials are valid.
4314        '''
4315        self.id = id if id is not None else ''
4316        '''
4317         Unique identifier of the Resource.
4318        '''
4319        self.name = name if name is not None else ''
4320        '''
4321         Unique human-readable name of the Resource.
4322        '''
4323        self.port_override = port_override if port_override is not None else 0
4324        self.region = region if region is not None else ''
4325        self.role_arn = role_arn if role_arn is not None else ''
4326        self.role_external_id = role_external_id if role_external_id is not None else ''
4327        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4328        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4329        '''
4330         ID of the secret store containing credentials for this resource, if any.
4331        '''
4332        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4333        '''
4334         Tags is a map of key, value pairs.
4335        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4355    def to_dict(self):
4356        return {
4357            'access_key': self.access_key,
4358            'bind_interface': self.bind_interface,
4359            'egress_filter': self.egress_filter,
4360            'endpoint': self.endpoint,
4361            'healthy': self.healthy,
4362            'id': self.id,
4363            'name': self.name,
4364            'port_override': self.port_override,
4365            'region': self.region,
4366            'role_arn': self.role_arn,
4367            'role_external_id': self.role_external_id,
4368            'secret_access_key': self.secret_access_key,
4369            'secret_store_id': self.secret_store_id,
4370            'tags': self.tags,
4371        }
@classmethod
def from_dict(cls, d)
4373    @classmethod
4374    def from_dict(cls, d):
4375        return cls(
4376            access_key=d.get('access_key'),
4377            bind_interface=d.get('bind_interface'),
4378            egress_filter=d.get('egress_filter'),
4379            endpoint=d.get('endpoint'),
4380            healthy=d.get('healthy'),
4381            id=d.get('id'),
4382            name=d.get('name'),
4383            port_override=d.get('port_override'),
4384            region=d.get('region'),
4385            role_arn=d.get('role_arn'),
4386            role_external_id=d.get('role_external_id'),
4387            secret_access_key=d.get('secret_access_key'),
4388            secret_store_id=d.get('secret_store_id'),
4389            tags=d.get('tags'),
4390        )
class Elastic:
4393class Elastic:
4394    __slots__ = [
4395        'bind_interface',
4396        'egress_filter',
4397        'healthy',
4398        'hostname',
4399        'id',
4400        'name',
4401        'password',
4402        'port',
4403        'port_override',
4404        'secret_store_id',
4405        'tags',
4406        'tls_required',
4407        'username',
4408    ]
4409
4410    def __init__(
4411        self,
4412        bind_interface=None,
4413        egress_filter=None,
4414        healthy=None,
4415        hostname=None,
4416        id=None,
4417        name=None,
4418        password=None,
4419        port=None,
4420        port_override=None,
4421        secret_store_id=None,
4422        tags=None,
4423        tls_required=None,
4424        username=None,
4425    ):
4426        self.bind_interface = bind_interface if bind_interface is not None else ''
4427        '''
4428         Bind interface
4429        '''
4430        self.egress_filter = egress_filter if egress_filter is not None else ''
4431        '''
4432         A filter applied to the routing logic to pin datasource to nodes.
4433        '''
4434        self.healthy = healthy if healthy is not None else False
4435        '''
4436         True if the datasource is reachable and the credentials are valid.
4437        '''
4438        self.hostname = hostname if hostname is not None else ''
4439        self.id = id if id is not None else ''
4440        '''
4441         Unique identifier of the Resource.
4442        '''
4443        self.name = name if name is not None else ''
4444        '''
4445         Unique human-readable name of the Resource.
4446        '''
4447        self.password = password if password is not None else ''
4448        self.port = port if port is not None else 0
4449        self.port_override = port_override if port_override is not None else 0
4450        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4451        '''
4452         ID of the secret store containing credentials for this resource, if any.
4453        '''
4454        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4455        '''
4456         Tags is a map of key, value pairs.
4457        '''
4458        self.tls_required = tls_required if tls_required is not None else False
4459        self.username = username if username is not None else ''
4460
4461    def __repr__(self):
4462        return '<sdm.Elastic ' + \
4463            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4464            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4465            'healthy: ' + repr(self.healthy) + ' ' +\
4466            'hostname: ' + repr(self.hostname) + ' ' +\
4467            'id: ' + repr(self.id) + ' ' +\
4468            'name: ' + repr(self.name) + ' ' +\
4469            'password: ' + repr(self.password) + ' ' +\
4470            'port: ' + repr(self.port) + ' ' +\
4471            'port_override: ' + repr(self.port_override) + ' ' +\
4472            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4473            'tags: ' + repr(self.tags) + ' ' +\
4474            'tls_required: ' + repr(self.tls_required) + ' ' +\
4475            'username: ' + repr(self.username) + ' ' +\
4476            '>'
4477
4478    def to_dict(self):
4479        return {
4480            'bind_interface': self.bind_interface,
4481            'egress_filter': self.egress_filter,
4482            'healthy': self.healthy,
4483            'hostname': self.hostname,
4484            'id': self.id,
4485            'name': self.name,
4486            'password': self.password,
4487            'port': self.port,
4488            'port_override': self.port_override,
4489            'secret_store_id': self.secret_store_id,
4490            'tags': self.tags,
4491            'tls_required': self.tls_required,
4492            'username': self.username,
4493        }
4494
4495    @classmethod
4496    def from_dict(cls, d):
4497        return cls(
4498            bind_interface=d.get('bind_interface'),
4499            egress_filter=d.get('egress_filter'),
4500            healthy=d.get('healthy'),
4501            hostname=d.get('hostname'),
4502            id=d.get('id'),
4503            name=d.get('name'),
4504            password=d.get('password'),
4505            port=d.get('port'),
4506            port_override=d.get('port_override'),
4507            secret_store_id=d.get('secret_store_id'),
4508            tags=d.get('tags'),
4509            tls_required=d.get('tls_required'),
4510            username=d.get('username'),
4511        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4410    def __init__(
4411        self,
4412        bind_interface=None,
4413        egress_filter=None,
4414        healthy=None,
4415        hostname=None,
4416        id=None,
4417        name=None,
4418        password=None,
4419        port=None,
4420        port_override=None,
4421        secret_store_id=None,
4422        tags=None,
4423        tls_required=None,
4424        username=None,
4425    ):
4426        self.bind_interface = bind_interface if bind_interface is not None else ''
4427        '''
4428         Bind interface
4429        '''
4430        self.egress_filter = egress_filter if egress_filter is not None else ''
4431        '''
4432         A filter applied to the routing logic to pin datasource to nodes.
4433        '''
4434        self.healthy = healthy if healthy is not None else False
4435        '''
4436         True if the datasource is reachable and the credentials are valid.
4437        '''
4438        self.hostname = hostname if hostname is not None else ''
4439        self.id = id if id is not None else ''
4440        '''
4441         Unique identifier of the Resource.
4442        '''
4443        self.name = name if name is not None else ''
4444        '''
4445         Unique human-readable name of the Resource.
4446        '''
4447        self.password = password if password is not None else ''
4448        self.port = port if port is not None else 0
4449        self.port_override = port_override if port_override is not None else 0
4450        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4451        '''
4452         ID of the secret store containing credentials for this resource, if any.
4453        '''
4454        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4455        '''
4456         Tags is a map of key, value pairs.
4457        '''
4458        self.tls_required = tls_required if tls_required is not None else False
4459        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4478    def to_dict(self):
4479        return {
4480            'bind_interface': self.bind_interface,
4481            'egress_filter': self.egress_filter,
4482            'healthy': self.healthy,
4483            'hostname': self.hostname,
4484            'id': self.id,
4485            'name': self.name,
4486            'password': self.password,
4487            'port': self.port,
4488            'port_override': self.port_override,
4489            'secret_store_id': self.secret_store_id,
4490            'tags': self.tags,
4491            'tls_required': self.tls_required,
4492            'username': self.username,
4493        }
@classmethod
def from_dict(cls, d)
4495    @classmethod
4496    def from_dict(cls, d):
4497        return cls(
4498            bind_interface=d.get('bind_interface'),
4499            egress_filter=d.get('egress_filter'),
4500            healthy=d.get('healthy'),
4501            hostname=d.get('hostname'),
4502            id=d.get('id'),
4503            name=d.get('name'),
4504            password=d.get('password'),
4505            port=d.get('port'),
4506            port_override=d.get('port_override'),
4507            secret_store_id=d.get('secret_store_id'),
4508            tags=d.get('tags'),
4509            tls_required=d.get('tls_required'),
4510            username=d.get('username'),
4511        )
class ElasticacheRedis:
4514class ElasticacheRedis:
4515    __slots__ = [
4516        'bind_interface',
4517        'egress_filter',
4518        'healthy',
4519        'hostname',
4520        'id',
4521        'name',
4522        'password',
4523        'port',
4524        'port_override',
4525        'secret_store_id',
4526        'tags',
4527        'tls_required',
4528    ]
4529
4530    def __init__(
4531        self,
4532        bind_interface=None,
4533        egress_filter=None,
4534        healthy=None,
4535        hostname=None,
4536        id=None,
4537        name=None,
4538        password=None,
4539        port=None,
4540        port_override=None,
4541        secret_store_id=None,
4542        tags=None,
4543        tls_required=None,
4544    ):
4545        self.bind_interface = bind_interface if bind_interface is not None else ''
4546        '''
4547         Bind interface
4548        '''
4549        self.egress_filter = egress_filter if egress_filter is not None else ''
4550        '''
4551         A filter applied to the routing logic to pin datasource to nodes.
4552        '''
4553        self.healthy = healthy if healthy is not None else False
4554        '''
4555         True if the datasource is reachable and the credentials are valid.
4556        '''
4557        self.hostname = hostname if hostname is not None else ''
4558        self.id = id if id is not None else ''
4559        '''
4560         Unique identifier of the Resource.
4561        '''
4562        self.name = name if name is not None else ''
4563        '''
4564         Unique human-readable name of the Resource.
4565        '''
4566        self.password = password if password is not None else ''
4567        self.port = port if port is not None else 0
4568        self.port_override = port_override if port_override is not None else 0
4569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4570        '''
4571         ID of the secret store containing credentials for this resource, if any.
4572        '''
4573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4574        '''
4575         Tags is a map of key, value pairs.
4576        '''
4577        self.tls_required = tls_required if tls_required is not None else False
4578
4579    def __repr__(self):
4580        return '<sdm.ElasticacheRedis ' + \
4581            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4582            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4583            'healthy: ' + repr(self.healthy) + ' ' +\
4584            'hostname: ' + repr(self.hostname) + ' ' +\
4585            'id: ' + repr(self.id) + ' ' +\
4586            'name: ' + repr(self.name) + ' ' +\
4587            'password: ' + repr(self.password) + ' ' +\
4588            'port: ' + repr(self.port) + ' ' +\
4589            'port_override: ' + repr(self.port_override) + ' ' +\
4590            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4591            'tags: ' + repr(self.tags) + ' ' +\
4592            'tls_required: ' + repr(self.tls_required) + ' ' +\
4593            '>'
4594
4595    def to_dict(self):
4596        return {
4597            'bind_interface': self.bind_interface,
4598            'egress_filter': self.egress_filter,
4599            'healthy': self.healthy,
4600            'hostname': self.hostname,
4601            'id': self.id,
4602            'name': self.name,
4603            'password': self.password,
4604            'port': self.port,
4605            'port_override': self.port_override,
4606            'secret_store_id': self.secret_store_id,
4607            'tags': self.tags,
4608            'tls_required': self.tls_required,
4609        }
4610
4611    @classmethod
4612    def from_dict(cls, d):
4613        return cls(
4614            bind_interface=d.get('bind_interface'),
4615            egress_filter=d.get('egress_filter'),
4616            healthy=d.get('healthy'),
4617            hostname=d.get('hostname'),
4618            id=d.get('id'),
4619            name=d.get('name'),
4620            password=d.get('password'),
4621            port=d.get('port'),
4622            port_override=d.get('port_override'),
4623            secret_store_id=d.get('secret_store_id'),
4624            tags=d.get('tags'),
4625            tls_required=d.get('tls_required'),
4626        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None)
4530    def __init__(
4531        self,
4532        bind_interface=None,
4533        egress_filter=None,
4534        healthy=None,
4535        hostname=None,
4536        id=None,
4537        name=None,
4538        password=None,
4539        port=None,
4540        port_override=None,
4541        secret_store_id=None,
4542        tags=None,
4543        tls_required=None,
4544    ):
4545        self.bind_interface = bind_interface if bind_interface is not None else ''
4546        '''
4547         Bind interface
4548        '''
4549        self.egress_filter = egress_filter if egress_filter is not None else ''
4550        '''
4551         A filter applied to the routing logic to pin datasource to nodes.
4552        '''
4553        self.healthy = healthy if healthy is not None else False
4554        '''
4555         True if the datasource is reachable and the credentials are valid.
4556        '''
4557        self.hostname = hostname if hostname is not None else ''
4558        self.id = id if id is not None else ''
4559        '''
4560         Unique identifier of the Resource.
4561        '''
4562        self.name = name if name is not None else ''
4563        '''
4564         Unique human-readable name of the Resource.
4565        '''
4566        self.password = password if password is not None else ''
4567        self.port = port if port is not None else 0
4568        self.port_override = port_override if port_override is not None else 0
4569        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4570        '''
4571         ID of the secret store containing credentials for this resource, if any.
4572        '''
4573        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4574        '''
4575         Tags is a map of key, value pairs.
4576        '''
4577        self.tls_required = tls_required if tls_required is not None else False
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
def to_dict(self)
4595    def to_dict(self):
4596        return {
4597            'bind_interface': self.bind_interface,
4598            'egress_filter': self.egress_filter,
4599            'healthy': self.healthy,
4600            'hostname': self.hostname,
4601            'id': self.id,
4602            'name': self.name,
4603            'password': self.password,
4604            'port': self.port,
4605            'port_override': self.port_override,
4606            'secret_store_id': self.secret_store_id,
4607            'tags': self.tags,
4608            'tls_required': self.tls_required,
4609        }
@classmethod
def from_dict(cls, d)
4611    @classmethod
4612    def from_dict(cls, d):
4613        return cls(
4614            bind_interface=d.get('bind_interface'),
4615            egress_filter=d.get('egress_filter'),
4616            healthy=d.get('healthy'),
4617            hostname=d.get('hostname'),
4618            id=d.get('id'),
4619            name=d.get('name'),
4620            password=d.get('password'),
4621            port=d.get('port'),
4622            port_override=d.get('port_override'),
4623            secret_store_id=d.get('secret_store_id'),
4624            tags=d.get('tags'),
4625            tls_required=d.get('tls_required'),
4626        )
class GCP:
4629class GCP:
4630    __slots__ = [
4631        'bind_interface',
4632        'egress_filter',
4633        'healthy',
4634        'id',
4635        'keyfile',
4636        'name',
4637        'scopes',
4638        'secret_store_id',
4639        'tags',
4640    ]
4641
4642    def __init__(
4643        self,
4644        bind_interface=None,
4645        egress_filter=None,
4646        healthy=None,
4647        id=None,
4648        keyfile=None,
4649        name=None,
4650        scopes=None,
4651        secret_store_id=None,
4652        tags=None,
4653    ):
4654        self.bind_interface = bind_interface if bind_interface is not None else ''
4655        '''
4656         Bind interface
4657        '''
4658        self.egress_filter = egress_filter if egress_filter is not None else ''
4659        '''
4660         A filter applied to the routing logic to pin datasource to nodes.
4661        '''
4662        self.healthy = healthy if healthy is not None else False
4663        '''
4664         True if the datasource is reachable and the credentials are valid.
4665        '''
4666        self.id = id if id is not None else ''
4667        '''
4668         Unique identifier of the Resource.
4669        '''
4670        self.keyfile = keyfile if keyfile is not None else ''
4671        self.name = name if name is not None else ''
4672        '''
4673         Unique human-readable name of the Resource.
4674        '''
4675        self.scopes = scopes if scopes is not None else ''
4676        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4677        '''
4678         ID of the secret store containing credentials for this resource, if any.
4679        '''
4680        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4681        '''
4682         Tags is a map of key, value pairs.
4683        '''
4684
4685    def __repr__(self):
4686        return '<sdm.GCP ' + \
4687            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4688            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4689            'healthy: ' + repr(self.healthy) + ' ' +\
4690            'id: ' + repr(self.id) + ' ' +\
4691            'keyfile: ' + repr(self.keyfile) + ' ' +\
4692            'name: ' + repr(self.name) + ' ' +\
4693            'scopes: ' + repr(self.scopes) + ' ' +\
4694            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4695            'tags: ' + repr(self.tags) + ' ' +\
4696            '>'
4697
4698    def to_dict(self):
4699        return {
4700            'bind_interface': self.bind_interface,
4701            'egress_filter': self.egress_filter,
4702            'healthy': self.healthy,
4703            'id': self.id,
4704            'keyfile': self.keyfile,
4705            'name': self.name,
4706            'scopes': self.scopes,
4707            'secret_store_id': self.secret_store_id,
4708            'tags': self.tags,
4709        }
4710
4711    @classmethod
4712    def from_dict(cls, d):
4713        return cls(
4714            bind_interface=d.get('bind_interface'),
4715            egress_filter=d.get('egress_filter'),
4716            healthy=d.get('healthy'),
4717            id=d.get('id'),
4718            keyfile=d.get('keyfile'),
4719            name=d.get('name'),
4720            scopes=d.get('scopes'),
4721            secret_store_id=d.get('secret_store_id'),
4722            tags=d.get('tags'),
4723        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
4642    def __init__(
4643        self,
4644        bind_interface=None,
4645        egress_filter=None,
4646        healthy=None,
4647        id=None,
4648        keyfile=None,
4649        name=None,
4650        scopes=None,
4651        secret_store_id=None,
4652        tags=None,
4653    ):
4654        self.bind_interface = bind_interface if bind_interface is not None else ''
4655        '''
4656         Bind interface
4657        '''
4658        self.egress_filter = egress_filter if egress_filter is not None else ''
4659        '''
4660         A filter applied to the routing logic to pin datasource to nodes.
4661        '''
4662        self.healthy = healthy if healthy is not None else False
4663        '''
4664         True if the datasource is reachable and the credentials are valid.
4665        '''
4666        self.id = id if id is not None else ''
4667        '''
4668         Unique identifier of the Resource.
4669        '''
4670        self.keyfile = keyfile if keyfile is not None else ''
4671        self.name = name if name is not None else ''
4672        '''
4673         Unique human-readable name of the Resource.
4674        '''
4675        self.scopes = scopes if scopes is not None else ''
4676        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4677        '''
4678         ID of the secret store containing credentials for this resource, if any.
4679        '''
4680        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4681        '''
4682         Tags is a map of key, value pairs.
4683        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4698    def to_dict(self):
4699        return {
4700            'bind_interface': self.bind_interface,
4701            'egress_filter': self.egress_filter,
4702            'healthy': self.healthy,
4703            'id': self.id,
4704            'keyfile': self.keyfile,
4705            'name': self.name,
4706            'scopes': self.scopes,
4707            'secret_store_id': self.secret_store_id,
4708            'tags': self.tags,
4709        }
@classmethod
def from_dict(cls, d)
4711    @classmethod
4712    def from_dict(cls, d):
4713        return cls(
4714            bind_interface=d.get('bind_interface'),
4715            egress_filter=d.get('egress_filter'),
4716            healthy=d.get('healthy'),
4717            id=d.get('id'),
4718            keyfile=d.get('keyfile'),
4719            name=d.get('name'),
4720            scopes=d.get('scopes'),
4721            secret_store_id=d.get('secret_store_id'),
4722            tags=d.get('tags'),
4723        )
class GCPStore:
4726class GCPStore:
4727    __slots__ = [
4728        'id',
4729        'name',
4730        'projectid',
4731        'tags',
4732    ]
4733
4734    def __init__(
4735        self,
4736        id=None,
4737        name=None,
4738        projectid=None,
4739        tags=None,
4740    ):
4741        self.id = id if id is not None else ''
4742        '''
4743         Unique identifier of the SecretStore.
4744        '''
4745        self.name = name if name is not None else ''
4746        '''
4747         Unique human-readable name of the SecretStore.
4748        '''
4749        self.projectid = projectid if projectid is not None else ''
4750        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4751        '''
4752         Tags is a map of key, value pairs.
4753        '''
4754
4755    def __repr__(self):
4756        return '<sdm.GCPStore ' + \
4757            'id: ' + repr(self.id) + ' ' +\
4758            'name: ' + repr(self.name) + ' ' +\
4759            'projectid: ' + repr(self.projectid) + ' ' +\
4760            'tags: ' + repr(self.tags) + ' ' +\
4761            '>'
4762
4763    def to_dict(self):
4764        return {
4765            'id': self.id,
4766            'name': self.name,
4767            'projectid': self.projectid,
4768            'tags': self.tags,
4769        }
4770
4771    @classmethod
4772    def from_dict(cls, d):
4773        return cls(
4774            id=d.get('id'),
4775            name=d.get('name'),
4776            projectid=d.get('projectid'),
4777            tags=d.get('tags'),
4778        )
GCPStore(id=None, name=None, projectid=None, tags=None)
4734    def __init__(
4735        self,
4736        id=None,
4737        name=None,
4738        projectid=None,
4739        tags=None,
4740    ):
4741        self.id = id if id is not None else ''
4742        '''
4743         Unique identifier of the SecretStore.
4744        '''
4745        self.name = name if name is not None else ''
4746        '''
4747         Unique human-readable name of the SecretStore.
4748        '''
4749        self.projectid = projectid if projectid is not None else ''
4750        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4751        '''
4752         Tags is a map of key, value pairs.
4753        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
4763    def to_dict(self):
4764        return {
4765            'id': self.id,
4766            'name': self.name,
4767            'projectid': self.projectid,
4768            'tags': self.tags,
4769        }
@classmethod
def from_dict(cls, d)
4771    @classmethod
4772    def from_dict(cls, d):
4773        return cls(
4774            id=d.get('id'),
4775            name=d.get('name'),
4776            projectid=d.get('projectid'),
4777            tags=d.get('tags'),
4778        )
class Gateway:
4781class Gateway:
4782    '''
4783         Gateway represents a StrongDM CLI installation running in gateway mode.
4784    '''
4785    __slots__ = [
4786        'bind_address',
4787        'gateway_filter',
4788        'id',
4789        'listen_address',
4790        'name',
4791        'state',
4792        'tags',
4793    ]
4794
4795    def __init__(
4796        self,
4797        bind_address=None,
4798        gateway_filter=None,
4799        id=None,
4800        listen_address=None,
4801        name=None,
4802        state=None,
4803        tags=None,
4804    ):
4805        self.bind_address = bind_address if bind_address is not None else ''
4806        '''
4807         The hostname/port tuple which the gateway daemon will bind to.
4808         If not provided on create, set to "0.0.0.0:listen_address_port".
4809        '''
4810        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
4811        '''
4812         GatewayFilter can be used to restrict the peering between relays and
4813         gateways.
4814        '''
4815        self.id = id if id is not None else ''
4816        '''
4817         Unique identifier of the Gateway.
4818        '''
4819        self.listen_address = listen_address if listen_address is not None else ''
4820        '''
4821         The public hostname/port tuple at which the gateway will be accessible to clients.
4822        '''
4823        self.name = name if name is not None else ''
4824        '''
4825         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
4826        '''
4827        self.state = state if state is not None else ''
4828        '''
4829         The current state of the gateway. One of: "new", "verifying_restart",
4830         "restarting", "started", "stopped", "dead", "unknown"
4831        '''
4832        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4833        '''
4834         Tags is a map of key, value pairs.
4835        '''
4836
4837    def __repr__(self):
4838        return '<sdm.Gateway ' + \
4839            'bind_address: ' + repr(self.bind_address) + ' ' +\
4840            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
4841            'id: ' + repr(self.id) + ' ' +\
4842            'listen_address: ' + repr(self.listen_address) + ' ' +\
4843            'name: ' + repr(self.name) + ' ' +\
4844            'state: ' + repr(self.state) + ' ' +\
4845            'tags: ' + repr(self.tags) + ' ' +\
4846            '>'
4847
4848    def to_dict(self):
4849        return {
4850            'bind_address': self.bind_address,
4851            'gateway_filter': self.gateway_filter,
4852            'id': self.id,
4853            'listen_address': self.listen_address,
4854            'name': self.name,
4855            'state': self.state,
4856            'tags': self.tags,
4857        }
4858
4859    @classmethod
4860    def from_dict(cls, d):
4861        return cls(
4862            bind_address=d.get('bind_address'),
4863            gateway_filter=d.get('gateway_filter'),
4864            id=d.get('id'),
4865            listen_address=d.get('listen_address'),
4866            name=d.get('name'),
4867            state=d.get('state'),
4868            tags=d.get('tags'),
4869        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, gateway_filter=None, id=None, listen_address=None, name=None, state=None, tags=None)
4795    def __init__(
4796        self,
4797        bind_address=None,
4798        gateway_filter=None,
4799        id=None,
4800        listen_address=None,
4801        name=None,
4802        state=None,
4803        tags=None,
4804    ):
4805        self.bind_address = bind_address if bind_address is not None else ''
4806        '''
4807         The hostname/port tuple which the gateway daemon will bind to.
4808         If not provided on create, set to "0.0.0.0:listen_address_port".
4809        '''
4810        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
4811        '''
4812         GatewayFilter can be used to restrict the peering between relays and
4813         gateways.
4814        '''
4815        self.id = id if id is not None else ''
4816        '''
4817         Unique identifier of the Gateway.
4818        '''
4819        self.listen_address = listen_address if listen_address is not None else ''
4820        '''
4821         The public hostname/port tuple at which the gateway will be accessible to clients.
4822        '''
4823        self.name = name if name is not None else ''
4824        '''
4825         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
4826        '''
4827        self.state = state if state is not None else ''
4828        '''
4829         The current state of the gateway. One of: "new", "verifying_restart",
4830         "restarting", "started", "stopped", "dead", "unknown"
4831        '''
4832        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4833        '''
4834         Tags is a map of key, value pairs.
4835        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

def to_dict(self)
4848    def to_dict(self):
4849        return {
4850            'bind_address': self.bind_address,
4851            'gateway_filter': self.gateway_filter,
4852            'id': self.id,
4853            'listen_address': self.listen_address,
4854            'name': self.name,
4855            'state': self.state,
4856            'tags': self.tags,
4857        }
@classmethod
def from_dict(cls, d)
4859    @classmethod
4860    def from_dict(cls, d):
4861        return cls(
4862            bind_address=d.get('bind_address'),
4863            gateway_filter=d.get('gateway_filter'),
4864            id=d.get('id'),
4865            listen_address=d.get('listen_address'),
4866            name=d.get('name'),
4867            state=d.get('state'),
4868            tags=d.get('tags'),
4869        )
class GetResponseMetadata:
4872class GetResponseMetadata:
4873    '''
4874         GetResponseMetadata is reserved for future use.
4875    '''
4876    __slots__ = []
4877
4878    def __init__(self, ):
4879        pass
4880
4881    def __repr__(self):
4882        return '<sdm.GetResponseMetadata ' + \
4883            '>'
4884
4885    def to_dict(self):
4886        return {}
4887
4888    @classmethod
4889    def from_dict(cls, d):
4890        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
4878    def __init__(self, ):
4879        pass
def to_dict(self)
4885    def to_dict(self):
4886        return {}
@classmethod
def from_dict(cls, d)
4888    @classmethod
4889    def from_dict(cls, d):
4890        return cls()
class GoogleGKE:
4893class GoogleGKE:
4894    __slots__ = [
4895        'bind_interface',
4896        'certificate_authority',
4897        'egress_filter',
4898        'endpoint',
4899        'healthcheck_namespace',
4900        'healthy',
4901        'id',
4902        'name',
4903        'remote_identity_group_id',
4904        'remote_identity_healthcheck_username',
4905        'secret_store_id',
4906        'service_account_key',
4907        'tags',
4908    ]
4909
4910    def __init__(
4911        self,
4912        bind_interface=None,
4913        certificate_authority=None,
4914        egress_filter=None,
4915        endpoint=None,
4916        healthcheck_namespace=None,
4917        healthy=None,
4918        id=None,
4919        name=None,
4920        remote_identity_group_id=None,
4921        remote_identity_healthcheck_username=None,
4922        secret_store_id=None,
4923        service_account_key=None,
4924        tags=None,
4925    ):
4926        self.bind_interface = bind_interface if bind_interface is not None else ''
4927        '''
4928         Bind interface
4929        '''
4930        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
4931        self.egress_filter = egress_filter if egress_filter is not None else ''
4932        '''
4933         A filter applied to the routing logic to pin datasource to nodes.
4934        '''
4935        self.endpoint = endpoint if endpoint is not None else ''
4936        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
4937        '''
4938         The path used to check the health of your connection.  Defaults to `default`.
4939        '''
4940        self.healthy = healthy if healthy is not None else False
4941        '''
4942         True if the datasource is reachable and the credentials are valid.
4943        '''
4944        self.id = id if id is not None else ''
4945        '''
4946         Unique identifier of the Resource.
4947        '''
4948        self.name = name if name is not None else ''
4949        '''
4950         Unique human-readable name of the Resource.
4951        '''
4952        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
4953        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
4954        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4955        '''
4956         ID of the secret store containing credentials for this resource, if any.
4957        '''
4958        self.service_account_key = service_account_key if service_account_key is not None else ''
4959        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4960        '''
4961         Tags is a map of key, value pairs.
4962        '''
4963
4964    def __repr__(self):
4965        return '<sdm.GoogleGKE ' + \
4966            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4967            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
4968            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4969            'endpoint: ' + repr(self.endpoint) + ' ' +\
4970            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
4971            'healthy: ' + repr(self.healthy) + ' ' +\
4972            'id: ' + repr(self.id) + ' ' +\
4973            'name: ' + repr(self.name) + ' ' +\
4974            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
4975            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
4976            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4977            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
4978            'tags: ' + repr(self.tags) + ' ' +\
4979            '>'
4980
4981    def to_dict(self):
4982        return {
4983            'bind_interface': self.bind_interface,
4984            'certificate_authority': self.certificate_authority,
4985            'egress_filter': self.egress_filter,
4986            'endpoint': self.endpoint,
4987            'healthcheck_namespace': self.healthcheck_namespace,
4988            'healthy': self.healthy,
4989            'id': self.id,
4990            'name': self.name,
4991            'remote_identity_group_id': self.remote_identity_group_id,
4992            'remote_identity_healthcheck_username':
4993            self.remote_identity_healthcheck_username,
4994            'secret_store_id': self.secret_store_id,
4995            'service_account_key': self.service_account_key,
4996            'tags': self.tags,
4997        }
4998
4999    @classmethod
5000    def from_dict(cls, d):
5001        return cls(
5002            bind_interface=d.get('bind_interface'),
5003            certificate_authority=d.get('certificate_authority'),
5004            egress_filter=d.get('egress_filter'),
5005            endpoint=d.get('endpoint'),
5006            healthcheck_namespace=d.get('healthcheck_namespace'),
5007            healthy=d.get('healthy'),
5008            id=d.get('id'),
5009            name=d.get('name'),
5010            remote_identity_group_id=d.get('remote_identity_group_id'),
5011            remote_identity_healthcheck_username=d.get(
5012                'remote_identity_healthcheck_username'),
5013            secret_store_id=d.get('secret_store_id'),
5014            service_account_key=d.get('service_account_key'),
5015            tags=d.get('tags'),
5016        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
4910    def __init__(
4911        self,
4912        bind_interface=None,
4913        certificate_authority=None,
4914        egress_filter=None,
4915        endpoint=None,
4916        healthcheck_namespace=None,
4917        healthy=None,
4918        id=None,
4919        name=None,
4920        remote_identity_group_id=None,
4921        remote_identity_healthcheck_username=None,
4922        secret_store_id=None,
4923        service_account_key=None,
4924        tags=None,
4925    ):
4926        self.bind_interface = bind_interface if bind_interface is not None else ''
4927        '''
4928         Bind interface
4929        '''
4930        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
4931        self.egress_filter = egress_filter if egress_filter is not None else ''
4932        '''
4933         A filter applied to the routing logic to pin datasource to nodes.
4934        '''
4935        self.endpoint = endpoint if endpoint is not None else ''
4936        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
4937        '''
4938         The path used to check the health of your connection.  Defaults to `default`.
4939        '''
4940        self.healthy = healthy if healthy is not None else False
4941        '''
4942         True if the datasource is reachable and the credentials are valid.
4943        '''
4944        self.id = id if id is not None else ''
4945        '''
4946         Unique identifier of the Resource.
4947        '''
4948        self.name = name if name is not None else ''
4949        '''
4950         Unique human-readable name of the Resource.
4951        '''
4952        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
4953        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
4954        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4955        '''
4956         ID of the secret store containing credentials for this resource, if any.
4957        '''
4958        self.service_account_key = service_account_key if service_account_key is not None else ''
4959        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4960        '''
4961         Tags is a map of key, value pairs.
4962        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
4981    def to_dict(self):
4982        return {
4983            'bind_interface': self.bind_interface,
4984            'certificate_authority': self.certificate_authority,
4985            'egress_filter': self.egress_filter,
4986            'endpoint': self.endpoint,
4987            'healthcheck_namespace': self.healthcheck_namespace,
4988            'healthy': self.healthy,
4989            'id': self.id,
4990            'name': self.name,
4991            'remote_identity_group_id': self.remote_identity_group_id,
4992            'remote_identity_healthcheck_username':
4993            self.remote_identity_healthcheck_username,
4994            'secret_store_id': self.secret_store_id,
4995            'service_account_key': self.service_account_key,
4996            'tags': self.tags,
4997        }
@classmethod
def from_dict(cls, d)
4999    @classmethod
5000    def from_dict(cls, d):
5001        return cls(
5002            bind_interface=d.get('bind_interface'),
5003            certificate_authority=d.get('certificate_authority'),
5004            egress_filter=d.get('egress_filter'),
5005            endpoint=d.get('endpoint'),
5006            healthcheck_namespace=d.get('healthcheck_namespace'),
5007            healthy=d.get('healthy'),
5008            id=d.get('id'),
5009            name=d.get('name'),
5010            remote_identity_group_id=d.get('remote_identity_group_id'),
5011            remote_identity_healthcheck_username=d.get(
5012                'remote_identity_healthcheck_username'),
5013            secret_store_id=d.get('secret_store_id'),
5014            service_account_key=d.get('service_account_key'),
5015            tags=d.get('tags'),
5016        )
class GoogleGKEUserImpersonation:
5019class GoogleGKEUserImpersonation:
5020    __slots__ = [
5021        'bind_interface',
5022        'certificate_authority',
5023        'egress_filter',
5024        'endpoint',
5025        'healthcheck_namespace',
5026        'healthy',
5027        'id',
5028        'name',
5029        'secret_store_id',
5030        'service_account_key',
5031        'tags',
5032    ]
5033
5034    def __init__(
5035        self,
5036        bind_interface=None,
5037        certificate_authority=None,
5038        egress_filter=None,
5039        endpoint=None,
5040        healthcheck_namespace=None,
5041        healthy=None,
5042        id=None,
5043        name=None,
5044        secret_store_id=None,
5045        service_account_key=None,
5046        tags=None,
5047    ):
5048        self.bind_interface = bind_interface if bind_interface is not None else ''
5049        '''
5050         Bind interface
5051        '''
5052        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5053        self.egress_filter = egress_filter if egress_filter is not None else ''
5054        '''
5055         A filter applied to the routing logic to pin datasource to nodes.
5056        '''
5057        self.endpoint = endpoint if endpoint is not None else ''
5058        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5059        '''
5060         The path used to check the health of your connection.  Defaults to `default`.
5061        '''
5062        self.healthy = healthy if healthy is not None else False
5063        '''
5064         True if the datasource is reachable and the credentials are valid.
5065        '''
5066        self.id = id if id is not None else ''
5067        '''
5068         Unique identifier of the Resource.
5069        '''
5070        self.name = name if name is not None else ''
5071        '''
5072         Unique human-readable name of the Resource.
5073        '''
5074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5075        '''
5076         ID of the secret store containing credentials for this resource, if any.
5077        '''
5078        self.service_account_key = service_account_key if service_account_key is not None else ''
5079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5080        '''
5081         Tags is a map of key, value pairs.
5082        '''
5083
5084    def __repr__(self):
5085        return '<sdm.GoogleGKEUserImpersonation ' + \
5086            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5087            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5088            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5089            'endpoint: ' + repr(self.endpoint) + ' ' +\
5090            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5091            'healthy: ' + repr(self.healthy) + ' ' +\
5092            'id: ' + repr(self.id) + ' ' +\
5093            'name: ' + repr(self.name) + ' ' +\
5094            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5095            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5096            'tags: ' + repr(self.tags) + ' ' +\
5097            '>'
5098
5099    def to_dict(self):
5100        return {
5101            'bind_interface': self.bind_interface,
5102            'certificate_authority': self.certificate_authority,
5103            'egress_filter': self.egress_filter,
5104            'endpoint': self.endpoint,
5105            'healthcheck_namespace': self.healthcheck_namespace,
5106            'healthy': self.healthy,
5107            'id': self.id,
5108            'name': self.name,
5109            'secret_store_id': self.secret_store_id,
5110            'service_account_key': self.service_account_key,
5111            'tags': self.tags,
5112        }
5113
5114    @classmethod
5115    def from_dict(cls, d):
5116        return cls(
5117            bind_interface=d.get('bind_interface'),
5118            certificate_authority=d.get('certificate_authority'),
5119            egress_filter=d.get('egress_filter'),
5120            endpoint=d.get('endpoint'),
5121            healthcheck_namespace=d.get('healthcheck_namespace'),
5122            healthy=d.get('healthy'),
5123            id=d.get('id'),
5124            name=d.get('name'),
5125            secret_store_id=d.get('secret_store_id'),
5126            service_account_key=d.get('service_account_key'),
5127            tags=d.get('tags'),
5128        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5034    def __init__(
5035        self,
5036        bind_interface=None,
5037        certificate_authority=None,
5038        egress_filter=None,
5039        endpoint=None,
5040        healthcheck_namespace=None,
5041        healthy=None,
5042        id=None,
5043        name=None,
5044        secret_store_id=None,
5045        service_account_key=None,
5046        tags=None,
5047    ):
5048        self.bind_interface = bind_interface if bind_interface is not None else ''
5049        '''
5050         Bind interface
5051        '''
5052        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5053        self.egress_filter = egress_filter if egress_filter is not None else ''
5054        '''
5055         A filter applied to the routing logic to pin datasource to nodes.
5056        '''
5057        self.endpoint = endpoint if endpoint is not None else ''
5058        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5059        '''
5060         The path used to check the health of your connection.  Defaults to `default`.
5061        '''
5062        self.healthy = healthy if healthy is not None else False
5063        '''
5064         True if the datasource is reachable and the credentials are valid.
5065        '''
5066        self.id = id if id is not None else ''
5067        '''
5068         Unique identifier of the Resource.
5069        '''
5070        self.name = name if name is not None else ''
5071        '''
5072         Unique human-readable name of the Resource.
5073        '''
5074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5075        '''
5076         ID of the secret store containing credentials for this resource, if any.
5077        '''
5078        self.service_account_key = service_account_key if service_account_key is not None else ''
5079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5080        '''
5081         Tags is a map of key, value pairs.
5082        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5099    def to_dict(self):
5100        return {
5101            'bind_interface': self.bind_interface,
5102            'certificate_authority': self.certificate_authority,
5103            'egress_filter': self.egress_filter,
5104            'endpoint': self.endpoint,
5105            'healthcheck_namespace': self.healthcheck_namespace,
5106            'healthy': self.healthy,
5107            'id': self.id,
5108            'name': self.name,
5109            'secret_store_id': self.secret_store_id,
5110            'service_account_key': self.service_account_key,
5111            'tags': self.tags,
5112        }
@classmethod
def from_dict(cls, d)
5114    @classmethod
5115    def from_dict(cls, d):
5116        return cls(
5117            bind_interface=d.get('bind_interface'),
5118            certificate_authority=d.get('certificate_authority'),
5119            egress_filter=d.get('egress_filter'),
5120            endpoint=d.get('endpoint'),
5121            healthcheck_namespace=d.get('healthcheck_namespace'),
5122            healthy=d.get('healthy'),
5123            id=d.get('id'),
5124            name=d.get('name'),
5125            secret_store_id=d.get('secret_store_id'),
5126            service_account_key=d.get('service_account_key'),
5127            tags=d.get('tags'),
5128        )
class Greenplum:
5131class Greenplum:
5132    __slots__ = [
5133        'bind_interface',
5134        'database',
5135        'egress_filter',
5136        'healthy',
5137        'hostname',
5138        'id',
5139        'name',
5140        'override_database',
5141        'password',
5142        'port',
5143        'port_override',
5144        'secret_store_id',
5145        'tags',
5146        'username',
5147    ]
5148
5149    def __init__(
5150        self,
5151        bind_interface=None,
5152        database=None,
5153        egress_filter=None,
5154        healthy=None,
5155        hostname=None,
5156        id=None,
5157        name=None,
5158        override_database=None,
5159        password=None,
5160        port=None,
5161        port_override=None,
5162        secret_store_id=None,
5163        tags=None,
5164        username=None,
5165    ):
5166        self.bind_interface = bind_interface if bind_interface is not None else ''
5167        '''
5168         Bind interface
5169        '''
5170        self.database = database if database is not None else ''
5171        self.egress_filter = egress_filter if egress_filter is not None else ''
5172        '''
5173         A filter applied to the routing logic to pin datasource to nodes.
5174        '''
5175        self.healthy = healthy if healthy is not None else False
5176        '''
5177         True if the datasource is reachable and the credentials are valid.
5178        '''
5179        self.hostname = hostname if hostname is not None else ''
5180        self.id = id if id is not None else ''
5181        '''
5182         Unique identifier of the Resource.
5183        '''
5184        self.name = name if name is not None else ''
5185        '''
5186         Unique human-readable name of the Resource.
5187        '''
5188        self.override_database = override_database if override_database is not None else False
5189        self.password = password if password is not None else ''
5190        self.port = port if port is not None else 0
5191        self.port_override = port_override if port_override is not None else 0
5192        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5193        '''
5194         ID of the secret store containing credentials for this resource, if any.
5195        '''
5196        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5197        '''
5198         Tags is a map of key, value pairs.
5199        '''
5200        self.username = username if username is not None else ''
5201
5202    def __repr__(self):
5203        return '<sdm.Greenplum ' + \
5204            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5205            'database: ' + repr(self.database) + ' ' +\
5206            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5207            'healthy: ' + repr(self.healthy) + ' ' +\
5208            'hostname: ' + repr(self.hostname) + ' ' +\
5209            'id: ' + repr(self.id) + ' ' +\
5210            'name: ' + repr(self.name) + ' ' +\
5211            'override_database: ' + repr(self.override_database) + ' ' +\
5212            'password: ' + repr(self.password) + ' ' +\
5213            'port: ' + repr(self.port) + ' ' +\
5214            'port_override: ' + repr(self.port_override) + ' ' +\
5215            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5216            'tags: ' + repr(self.tags) + ' ' +\
5217            'username: ' + repr(self.username) + ' ' +\
5218            '>'
5219
5220    def to_dict(self):
5221        return {
5222            'bind_interface': self.bind_interface,
5223            'database': self.database,
5224            'egress_filter': self.egress_filter,
5225            'healthy': self.healthy,
5226            'hostname': self.hostname,
5227            'id': self.id,
5228            'name': self.name,
5229            'override_database': self.override_database,
5230            'password': self.password,
5231            'port': self.port,
5232            'port_override': self.port_override,
5233            'secret_store_id': self.secret_store_id,
5234            'tags': self.tags,
5235            'username': self.username,
5236        }
5237
5238    @classmethod
5239    def from_dict(cls, d):
5240        return cls(
5241            bind_interface=d.get('bind_interface'),
5242            database=d.get('database'),
5243            egress_filter=d.get('egress_filter'),
5244            healthy=d.get('healthy'),
5245            hostname=d.get('hostname'),
5246            id=d.get('id'),
5247            name=d.get('name'),
5248            override_database=d.get('override_database'),
5249            password=d.get('password'),
5250            port=d.get('port'),
5251            port_override=d.get('port_override'),
5252            secret_store_id=d.get('secret_store_id'),
5253            tags=d.get('tags'),
5254            username=d.get('username'),
5255        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5149    def __init__(
5150        self,
5151        bind_interface=None,
5152        database=None,
5153        egress_filter=None,
5154        healthy=None,
5155        hostname=None,
5156        id=None,
5157        name=None,
5158        override_database=None,
5159        password=None,
5160        port=None,
5161        port_override=None,
5162        secret_store_id=None,
5163        tags=None,
5164        username=None,
5165    ):
5166        self.bind_interface = bind_interface if bind_interface is not None else ''
5167        '''
5168         Bind interface
5169        '''
5170        self.database = database if database is not None else ''
5171        self.egress_filter = egress_filter if egress_filter is not None else ''
5172        '''
5173         A filter applied to the routing logic to pin datasource to nodes.
5174        '''
5175        self.healthy = healthy if healthy is not None else False
5176        '''
5177         True if the datasource is reachable and the credentials are valid.
5178        '''
5179        self.hostname = hostname if hostname is not None else ''
5180        self.id = id if id is not None else ''
5181        '''
5182         Unique identifier of the Resource.
5183        '''
5184        self.name = name if name is not None else ''
5185        '''
5186         Unique human-readable name of the Resource.
5187        '''
5188        self.override_database = override_database if override_database is not None else False
5189        self.password = password if password is not None else ''
5190        self.port = port if port is not None else 0
5191        self.port_override = port_override if port_override is not None else 0
5192        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5193        '''
5194         ID of the secret store containing credentials for this resource, if any.
5195        '''
5196        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5197        '''
5198         Tags is a map of key, value pairs.
5199        '''
5200        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5220    def to_dict(self):
5221        return {
5222            'bind_interface': self.bind_interface,
5223            'database': self.database,
5224            'egress_filter': self.egress_filter,
5225            'healthy': self.healthy,
5226            'hostname': self.hostname,
5227            'id': self.id,
5228            'name': self.name,
5229            'override_database': self.override_database,
5230            'password': self.password,
5231            'port': self.port,
5232            'port_override': self.port_override,
5233            'secret_store_id': self.secret_store_id,
5234            'tags': self.tags,
5235            'username': self.username,
5236        }
@classmethod
def from_dict(cls, d)
5238    @classmethod
5239    def from_dict(cls, d):
5240        return cls(
5241            bind_interface=d.get('bind_interface'),
5242            database=d.get('database'),
5243            egress_filter=d.get('egress_filter'),
5244            healthy=d.get('healthy'),
5245            hostname=d.get('hostname'),
5246            id=d.get('id'),
5247            name=d.get('name'),
5248            override_database=d.get('override_database'),
5249            password=d.get('password'),
5250            port=d.get('port'),
5251            port_override=d.get('port_override'),
5252            secret_store_id=d.get('secret_store_id'),
5253            tags=d.get('tags'),
5254            username=d.get('username'),
5255        )
class HTTPAuth:
5258class HTTPAuth:
5259    __slots__ = [
5260        'auth_header',
5261        'bind_interface',
5262        'default_path',
5263        'egress_filter',
5264        'headers_blacklist',
5265        'healthcheck_path',
5266        'healthy',
5267        'id',
5268        'name',
5269        'secret_store_id',
5270        'subdomain',
5271        'tags',
5272        'url',
5273    ]
5274
5275    def __init__(
5276        self,
5277        auth_header=None,
5278        bind_interface=None,
5279        default_path=None,
5280        egress_filter=None,
5281        headers_blacklist=None,
5282        healthcheck_path=None,
5283        healthy=None,
5284        id=None,
5285        name=None,
5286        secret_store_id=None,
5287        subdomain=None,
5288        tags=None,
5289        url=None,
5290    ):
5291        self.auth_header = auth_header if auth_header is not None else ''
5292        self.bind_interface = bind_interface if bind_interface is not None else ''
5293        '''
5294         Bind interface
5295        '''
5296        self.default_path = default_path if default_path is not None else ''
5297        self.egress_filter = egress_filter if egress_filter is not None else ''
5298        '''
5299         A filter applied to the routing logic to pin datasource to nodes.
5300        '''
5301        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5302        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5303        self.healthy = healthy if healthy is not None else False
5304        '''
5305         True if the datasource is reachable and the credentials are valid.
5306        '''
5307        self.id = id if id is not None else ''
5308        '''
5309         Unique identifier of the Resource.
5310        '''
5311        self.name = name if name is not None else ''
5312        '''
5313         Unique human-readable name of the Resource.
5314        '''
5315        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5316        '''
5317         ID of the secret store containing credentials for this resource, if any.
5318        '''
5319        self.subdomain = subdomain if subdomain is not None else ''
5320        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5321        '''
5322         Tags is a map of key, value pairs.
5323        '''
5324        self.url = url if url is not None else ''
5325
5326    def __repr__(self):
5327        return '<sdm.HTTPAuth ' + \
5328            'auth_header: ' + repr(self.auth_header) + ' ' +\
5329            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5330            'default_path: ' + repr(self.default_path) + ' ' +\
5331            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5332            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5333            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5334            'healthy: ' + repr(self.healthy) + ' ' +\
5335            'id: ' + repr(self.id) + ' ' +\
5336            'name: ' + repr(self.name) + ' ' +\
5337            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5338            'subdomain: ' + repr(self.subdomain) + ' ' +\
5339            'tags: ' + repr(self.tags) + ' ' +\
5340            'url: ' + repr(self.url) + ' ' +\
5341            '>'
5342
5343    def to_dict(self):
5344        return {
5345            'auth_header': self.auth_header,
5346            'bind_interface': self.bind_interface,
5347            'default_path': self.default_path,
5348            'egress_filter': self.egress_filter,
5349            'headers_blacklist': self.headers_blacklist,
5350            'healthcheck_path': self.healthcheck_path,
5351            'healthy': self.healthy,
5352            'id': self.id,
5353            'name': self.name,
5354            'secret_store_id': self.secret_store_id,
5355            'subdomain': self.subdomain,
5356            'tags': self.tags,
5357            'url': self.url,
5358        }
5359
5360    @classmethod
5361    def from_dict(cls, d):
5362        return cls(
5363            auth_header=d.get('auth_header'),
5364            bind_interface=d.get('bind_interface'),
5365            default_path=d.get('default_path'),
5366            egress_filter=d.get('egress_filter'),
5367            headers_blacklist=d.get('headers_blacklist'),
5368            healthcheck_path=d.get('healthcheck_path'),
5369            healthy=d.get('healthy'),
5370            id=d.get('id'),
5371            name=d.get('name'),
5372            secret_store_id=d.get('secret_store_id'),
5373            subdomain=d.get('subdomain'),
5374            tags=d.get('tags'),
5375            url=d.get('url'),
5376        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5275    def __init__(
5276        self,
5277        auth_header=None,
5278        bind_interface=None,
5279        default_path=None,
5280        egress_filter=None,
5281        headers_blacklist=None,
5282        healthcheck_path=None,
5283        healthy=None,
5284        id=None,
5285        name=None,
5286        secret_store_id=None,
5287        subdomain=None,
5288        tags=None,
5289        url=None,
5290    ):
5291        self.auth_header = auth_header if auth_header is not None else ''
5292        self.bind_interface = bind_interface if bind_interface is not None else ''
5293        '''
5294         Bind interface
5295        '''
5296        self.default_path = default_path if default_path is not None else ''
5297        self.egress_filter = egress_filter if egress_filter is not None else ''
5298        '''
5299         A filter applied to the routing logic to pin datasource to nodes.
5300        '''
5301        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5302        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5303        self.healthy = healthy if healthy is not None else False
5304        '''
5305         True if the datasource is reachable and the credentials are valid.
5306        '''
5307        self.id = id if id is not None else ''
5308        '''
5309         Unique identifier of the Resource.
5310        '''
5311        self.name = name if name is not None else ''
5312        '''
5313         Unique human-readable name of the Resource.
5314        '''
5315        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5316        '''
5317         ID of the secret store containing credentials for this resource, if any.
5318        '''
5319        self.subdomain = subdomain if subdomain is not None else ''
5320        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5321        '''
5322         Tags is a map of key, value pairs.
5323        '''
5324        self.url = url if url is not None else ''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5343    def to_dict(self):
5344        return {
5345            'auth_header': self.auth_header,
5346            'bind_interface': self.bind_interface,
5347            'default_path': self.default_path,
5348            'egress_filter': self.egress_filter,
5349            'headers_blacklist': self.headers_blacklist,
5350            'healthcheck_path': self.healthcheck_path,
5351            'healthy': self.healthy,
5352            'id': self.id,
5353            'name': self.name,
5354            'secret_store_id': self.secret_store_id,
5355            'subdomain': self.subdomain,
5356            'tags': self.tags,
5357            'url': self.url,
5358        }
@classmethod
def from_dict(cls, d)
5360    @classmethod
5361    def from_dict(cls, d):
5362        return cls(
5363            auth_header=d.get('auth_header'),
5364            bind_interface=d.get('bind_interface'),
5365            default_path=d.get('default_path'),
5366            egress_filter=d.get('egress_filter'),
5367            headers_blacklist=d.get('headers_blacklist'),
5368            healthcheck_path=d.get('healthcheck_path'),
5369            healthy=d.get('healthy'),
5370            id=d.get('id'),
5371            name=d.get('name'),
5372            secret_store_id=d.get('secret_store_id'),
5373            subdomain=d.get('subdomain'),
5374            tags=d.get('tags'),
5375            url=d.get('url'),
5376        )
class HTTPBasicAuth:
5379class HTTPBasicAuth:
5380    __slots__ = [
5381        'bind_interface',
5382        'default_path',
5383        'egress_filter',
5384        'headers_blacklist',
5385        'healthcheck_path',
5386        'healthy',
5387        'id',
5388        'name',
5389        'password',
5390        'secret_store_id',
5391        'subdomain',
5392        'tags',
5393        'url',
5394        'username',
5395    ]
5396
5397    def __init__(
5398        self,
5399        bind_interface=None,
5400        default_path=None,
5401        egress_filter=None,
5402        headers_blacklist=None,
5403        healthcheck_path=None,
5404        healthy=None,
5405        id=None,
5406        name=None,
5407        password=None,
5408        secret_store_id=None,
5409        subdomain=None,
5410        tags=None,
5411        url=None,
5412        username=None,
5413    ):
5414        self.bind_interface = bind_interface if bind_interface is not None else ''
5415        '''
5416         Bind interface
5417        '''
5418        self.default_path = default_path if default_path is not None else ''
5419        self.egress_filter = egress_filter if egress_filter is not None else ''
5420        '''
5421         A filter applied to the routing logic to pin datasource to nodes.
5422        '''
5423        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5424        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5425        self.healthy = healthy if healthy is not None else False
5426        '''
5427         True if the datasource is reachable and the credentials are valid.
5428        '''
5429        self.id = id if id is not None else ''
5430        '''
5431         Unique identifier of the Resource.
5432        '''
5433        self.name = name if name is not None else ''
5434        '''
5435         Unique human-readable name of the Resource.
5436        '''
5437        self.password = password if password is not None else ''
5438        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5439        '''
5440         ID of the secret store containing credentials for this resource, if any.
5441        '''
5442        self.subdomain = subdomain if subdomain is not None else ''
5443        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5444        '''
5445         Tags is a map of key, value pairs.
5446        '''
5447        self.url = url if url is not None else ''
5448        self.username = username if username is not None else ''
5449
5450    def __repr__(self):
5451        return '<sdm.HTTPBasicAuth ' + \
5452            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5453            'default_path: ' + repr(self.default_path) + ' ' +\
5454            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5455            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5456            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5457            'healthy: ' + repr(self.healthy) + ' ' +\
5458            'id: ' + repr(self.id) + ' ' +\
5459            'name: ' + repr(self.name) + ' ' +\
5460            'password: ' + repr(self.password) + ' ' +\
5461            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5462            'subdomain: ' + repr(self.subdomain) + ' ' +\
5463            'tags: ' + repr(self.tags) + ' ' +\
5464            'url: ' + repr(self.url) + ' ' +\
5465            'username: ' + repr(self.username) + ' ' +\
5466            '>'
5467
5468    def to_dict(self):
5469        return {
5470            'bind_interface': self.bind_interface,
5471            'default_path': self.default_path,
5472            'egress_filter': self.egress_filter,
5473            'headers_blacklist': self.headers_blacklist,
5474            'healthcheck_path': self.healthcheck_path,
5475            'healthy': self.healthy,
5476            'id': self.id,
5477            'name': self.name,
5478            'password': self.password,
5479            'secret_store_id': self.secret_store_id,
5480            'subdomain': self.subdomain,
5481            'tags': self.tags,
5482            'url': self.url,
5483            'username': self.username,
5484        }
5485
5486    @classmethod
5487    def from_dict(cls, d):
5488        return cls(
5489            bind_interface=d.get('bind_interface'),
5490            default_path=d.get('default_path'),
5491            egress_filter=d.get('egress_filter'),
5492            headers_blacklist=d.get('headers_blacklist'),
5493            healthcheck_path=d.get('healthcheck_path'),
5494            healthy=d.get('healthy'),
5495            id=d.get('id'),
5496            name=d.get('name'),
5497            password=d.get('password'),
5498            secret_store_id=d.get('secret_store_id'),
5499            subdomain=d.get('subdomain'),
5500            tags=d.get('tags'),
5501            url=d.get('url'),
5502            username=d.get('username'),
5503        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
5397    def __init__(
5398        self,
5399        bind_interface=None,
5400        default_path=None,
5401        egress_filter=None,
5402        headers_blacklist=None,
5403        healthcheck_path=None,
5404        healthy=None,
5405        id=None,
5406        name=None,
5407        password=None,
5408        secret_store_id=None,
5409        subdomain=None,
5410        tags=None,
5411        url=None,
5412        username=None,
5413    ):
5414        self.bind_interface = bind_interface if bind_interface is not None else ''
5415        '''
5416         Bind interface
5417        '''
5418        self.default_path = default_path if default_path is not None else ''
5419        self.egress_filter = egress_filter if egress_filter is not None else ''
5420        '''
5421         A filter applied to the routing logic to pin datasource to nodes.
5422        '''
5423        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5424        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5425        self.healthy = healthy if healthy is not None else False
5426        '''
5427         True if the datasource is reachable and the credentials are valid.
5428        '''
5429        self.id = id if id is not None else ''
5430        '''
5431         Unique identifier of the Resource.
5432        '''
5433        self.name = name if name is not None else ''
5434        '''
5435         Unique human-readable name of the Resource.
5436        '''
5437        self.password = password if password is not None else ''
5438        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5439        '''
5440         ID of the secret store containing credentials for this resource, if any.
5441        '''
5442        self.subdomain = subdomain if subdomain is not None else ''
5443        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5444        '''
5445         Tags is a map of key, value pairs.
5446        '''
5447        self.url = url if url is not None else ''
5448        self.username = username if username is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
5468    def to_dict(self):
5469        return {
5470            'bind_interface': self.bind_interface,
5471            'default_path': self.default_path,
5472            'egress_filter': self.egress_filter,
5473            'headers_blacklist': self.headers_blacklist,
5474            'healthcheck_path': self.healthcheck_path,
5475            'healthy': self.healthy,
5476            'id': self.id,
5477            'name': self.name,
5478            'password': self.password,
5479            'secret_store_id': self.secret_store_id,
5480            'subdomain': self.subdomain,
5481            'tags': self.tags,
5482            'url': self.url,
5483            'username': self.username,
5484        }
@classmethod
def from_dict(cls, d)
5486    @classmethod
5487    def from_dict(cls, d):
5488        return cls(
5489            bind_interface=d.get('bind_interface'),
5490            default_path=d.get('default_path'),
5491            egress_filter=d.get('egress_filter'),
5492            headers_blacklist=d.get('headers_blacklist'),
5493            healthcheck_path=d.get('healthcheck_path'),
5494            healthy=d.get('healthy'),
5495            id=d.get('id'),
5496            name=d.get('name'),
5497            password=d.get('password'),
5498            secret_store_id=d.get('secret_store_id'),
5499            subdomain=d.get('subdomain'),
5500            tags=d.get('tags'),
5501            url=d.get('url'),
5502            username=d.get('username'),
5503        )
class HTTPNoAuth:
5506class HTTPNoAuth:
5507    __slots__ = [
5508        'bind_interface',
5509        'default_path',
5510        'egress_filter',
5511        'headers_blacklist',
5512        'healthcheck_path',
5513        'healthy',
5514        'id',
5515        'name',
5516        'secret_store_id',
5517        'subdomain',
5518        'tags',
5519        'url',
5520    ]
5521
5522    def __init__(
5523        self,
5524        bind_interface=None,
5525        default_path=None,
5526        egress_filter=None,
5527        headers_blacklist=None,
5528        healthcheck_path=None,
5529        healthy=None,
5530        id=None,
5531        name=None,
5532        secret_store_id=None,
5533        subdomain=None,
5534        tags=None,
5535        url=None,
5536    ):
5537        self.bind_interface = bind_interface if bind_interface is not None else ''
5538        '''
5539         Bind interface
5540        '''
5541        self.default_path = default_path if default_path is not None else ''
5542        self.egress_filter = egress_filter if egress_filter is not None else ''
5543        '''
5544         A filter applied to the routing logic to pin datasource to nodes.
5545        '''
5546        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5547        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5548        self.healthy = healthy if healthy is not None else False
5549        '''
5550         True if the datasource is reachable and the credentials are valid.
5551        '''
5552        self.id = id if id is not None else ''
5553        '''
5554         Unique identifier of the Resource.
5555        '''
5556        self.name = name if name is not None else ''
5557        '''
5558         Unique human-readable name of the Resource.
5559        '''
5560        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5561        '''
5562         ID of the secret store containing credentials for this resource, if any.
5563        '''
5564        self.subdomain = subdomain if subdomain is not None else ''
5565        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5566        '''
5567         Tags is a map of key, value pairs.
5568        '''
5569        self.url = url if url is not None else ''
5570
5571    def __repr__(self):
5572        return '<sdm.HTTPNoAuth ' + \
5573            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5574            'default_path: ' + repr(self.default_path) + ' ' +\
5575            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5576            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5577            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5578            'healthy: ' + repr(self.healthy) + ' ' +\
5579            'id: ' + repr(self.id) + ' ' +\
5580            'name: ' + repr(self.name) + ' ' +\
5581            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5582            'subdomain: ' + repr(self.subdomain) + ' ' +\
5583            'tags: ' + repr(self.tags) + ' ' +\
5584            'url: ' + repr(self.url) + ' ' +\
5585            '>'
5586
5587    def to_dict(self):
5588        return {
5589            'bind_interface': self.bind_interface,
5590            'default_path': self.default_path,
5591            'egress_filter': self.egress_filter,
5592            'headers_blacklist': self.headers_blacklist,
5593            'healthcheck_path': self.healthcheck_path,
5594            'healthy': self.healthy,
5595            'id': self.id,
5596            'name': self.name,
5597            'secret_store_id': self.secret_store_id,
5598            'subdomain': self.subdomain,
5599            'tags': self.tags,
5600            'url': self.url,
5601        }
5602
5603    @classmethod
5604    def from_dict(cls, d):
5605        return cls(
5606            bind_interface=d.get('bind_interface'),
5607            default_path=d.get('default_path'),
5608            egress_filter=d.get('egress_filter'),
5609            headers_blacklist=d.get('headers_blacklist'),
5610            healthcheck_path=d.get('healthcheck_path'),
5611            healthy=d.get('healthy'),
5612            id=d.get('id'),
5613            name=d.get('name'),
5614            secret_store_id=d.get('secret_store_id'),
5615            subdomain=d.get('subdomain'),
5616            tags=d.get('tags'),
5617            url=d.get('url'),
5618        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5522    def __init__(
5523        self,
5524        bind_interface=None,
5525        default_path=None,
5526        egress_filter=None,
5527        headers_blacklist=None,
5528        healthcheck_path=None,
5529        healthy=None,
5530        id=None,
5531        name=None,
5532        secret_store_id=None,
5533        subdomain=None,
5534        tags=None,
5535        url=None,
5536    ):
5537        self.bind_interface = bind_interface if bind_interface is not None else ''
5538        '''
5539         Bind interface
5540        '''
5541        self.default_path = default_path if default_path is not None else ''
5542        self.egress_filter = egress_filter if egress_filter is not None else ''
5543        '''
5544         A filter applied to the routing logic to pin datasource to nodes.
5545        '''
5546        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5547        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5548        self.healthy = healthy if healthy is not None else False
5549        '''
5550         True if the datasource is reachable and the credentials are valid.
5551        '''
5552        self.id = id if id is not None else ''
5553        '''
5554         Unique identifier of the Resource.
5555        '''
5556        self.name = name if name is not None else ''
5557        '''
5558         Unique human-readable name of the Resource.
5559        '''
5560        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5561        '''
5562         ID of the secret store containing credentials for this resource, if any.
5563        '''
5564        self.subdomain = subdomain if subdomain is not None else ''
5565        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5566        '''
5567         Tags is a map of key, value pairs.
5568        '''
5569        self.url = url if url is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5587    def to_dict(self):
5588        return {
5589            'bind_interface': self.bind_interface,
5590            'default_path': self.default_path,
5591            'egress_filter': self.egress_filter,
5592            'headers_blacklist': self.headers_blacklist,
5593            'healthcheck_path': self.healthcheck_path,
5594            'healthy': self.healthy,
5595            'id': self.id,
5596            'name': self.name,
5597            'secret_store_id': self.secret_store_id,
5598            'subdomain': self.subdomain,
5599            'tags': self.tags,
5600            'url': self.url,
5601        }
@classmethod
def from_dict(cls, d)
5603    @classmethod
5604    def from_dict(cls, d):
5605        return cls(
5606            bind_interface=d.get('bind_interface'),
5607            default_path=d.get('default_path'),
5608            egress_filter=d.get('egress_filter'),
5609            headers_blacklist=d.get('headers_blacklist'),
5610            healthcheck_path=d.get('healthcheck_path'),
5611            healthy=d.get('healthy'),
5612            id=d.get('id'),
5613            name=d.get('name'),
5614            secret_store_id=d.get('secret_store_id'),
5615            subdomain=d.get('subdomain'),
5616            tags=d.get('tags'),
5617            url=d.get('url'),
5618        )
class Kubernetes:
5621class Kubernetes:
5622    __slots__ = [
5623        'bind_interface',
5624        'certificate_authority',
5625        'client_certificate',
5626        'client_key',
5627        'egress_filter',
5628        'healthcheck_namespace',
5629        'healthy',
5630        'hostname',
5631        'id',
5632        'name',
5633        'port',
5634        'port_override',
5635        'remote_identity_group_id',
5636        'remote_identity_healthcheck_username',
5637        'secret_store_id',
5638        'tags',
5639    ]
5640
5641    def __init__(
5642        self,
5643        bind_interface=None,
5644        certificate_authority=None,
5645        client_certificate=None,
5646        client_key=None,
5647        egress_filter=None,
5648        healthcheck_namespace=None,
5649        healthy=None,
5650        hostname=None,
5651        id=None,
5652        name=None,
5653        port=None,
5654        port_override=None,
5655        remote_identity_group_id=None,
5656        remote_identity_healthcheck_username=None,
5657        secret_store_id=None,
5658        tags=None,
5659    ):
5660        self.bind_interface = bind_interface if bind_interface is not None else ''
5661        '''
5662         Bind interface
5663        '''
5664        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5665        self.client_certificate = client_certificate if client_certificate is not None else ''
5666        self.client_key = client_key if client_key is not None else ''
5667        self.egress_filter = egress_filter if egress_filter is not None else ''
5668        '''
5669         A filter applied to the routing logic to pin datasource to nodes.
5670        '''
5671        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5672        '''
5673         The path used to check the health of your connection.  Defaults to `default`.
5674        '''
5675        self.healthy = healthy if healthy is not None else False
5676        '''
5677         True if the datasource is reachable and the credentials are valid.
5678        '''
5679        self.hostname = hostname if hostname is not None else ''
5680        self.id = id if id is not None else ''
5681        '''
5682         Unique identifier of the Resource.
5683        '''
5684        self.name = name if name is not None else ''
5685        '''
5686         Unique human-readable name of the Resource.
5687        '''
5688        self.port = port if port is not None else 0
5689        self.port_override = port_override if port_override is not None else 0
5690        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5691        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5692        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5693        '''
5694         ID of the secret store containing credentials for this resource, if any.
5695        '''
5696        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5697        '''
5698         Tags is a map of key, value pairs.
5699        '''
5700
5701    def __repr__(self):
5702        return '<sdm.Kubernetes ' + \
5703            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5704            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5705            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
5706            'client_key: ' + repr(self.client_key) + ' ' +\
5707            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5708            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5709            'healthy: ' + repr(self.healthy) + ' ' +\
5710            'hostname: ' + repr(self.hostname) + ' ' +\
5711            'id: ' + repr(self.id) + ' ' +\
5712            'name: ' + repr(self.name) + ' ' +\
5713            'port: ' + repr(self.port) + ' ' +\
5714            'port_override: ' + repr(self.port_override) + ' ' +\
5715            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5716            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5717            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5718            'tags: ' + repr(self.tags) + ' ' +\
5719            '>'
5720
5721    def to_dict(self):
5722        return {
5723            'bind_interface': self.bind_interface,
5724            'certificate_authority': self.certificate_authority,
5725            'client_certificate': self.client_certificate,
5726            'client_key': self.client_key,
5727            'egress_filter': self.egress_filter,
5728            'healthcheck_namespace': self.healthcheck_namespace,
5729            'healthy': self.healthy,
5730            'hostname': self.hostname,
5731            'id': self.id,
5732            'name': self.name,
5733            'port': self.port,
5734            'port_override': self.port_override,
5735            'remote_identity_group_id': self.remote_identity_group_id,
5736            'remote_identity_healthcheck_username':
5737            self.remote_identity_healthcheck_username,
5738            'secret_store_id': self.secret_store_id,
5739            'tags': self.tags,
5740        }
5741
5742    @classmethod
5743    def from_dict(cls, d):
5744        return cls(
5745            bind_interface=d.get('bind_interface'),
5746            certificate_authority=d.get('certificate_authority'),
5747            client_certificate=d.get('client_certificate'),
5748            client_key=d.get('client_key'),
5749            egress_filter=d.get('egress_filter'),
5750            healthcheck_namespace=d.get('healthcheck_namespace'),
5751            healthy=d.get('healthy'),
5752            hostname=d.get('hostname'),
5753            id=d.get('id'),
5754            name=d.get('name'),
5755            port=d.get('port'),
5756            port_override=d.get('port_override'),
5757            remote_identity_group_id=d.get('remote_identity_group_id'),
5758            remote_identity_healthcheck_username=d.get(
5759                'remote_identity_healthcheck_username'),
5760            secret_store_id=d.get('secret_store_id'),
5761            tags=d.get('tags'),
5762        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
5641    def __init__(
5642        self,
5643        bind_interface=None,
5644        certificate_authority=None,
5645        client_certificate=None,
5646        client_key=None,
5647        egress_filter=None,
5648        healthcheck_namespace=None,
5649        healthy=None,
5650        hostname=None,
5651        id=None,
5652        name=None,
5653        port=None,
5654        port_override=None,
5655        remote_identity_group_id=None,
5656        remote_identity_healthcheck_username=None,
5657        secret_store_id=None,
5658        tags=None,
5659    ):
5660        self.bind_interface = bind_interface if bind_interface is not None else ''
5661        '''
5662         Bind interface
5663        '''
5664        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5665        self.client_certificate = client_certificate if client_certificate is not None else ''
5666        self.client_key = client_key if client_key is not None else ''
5667        self.egress_filter = egress_filter if egress_filter is not None else ''
5668        '''
5669         A filter applied to the routing logic to pin datasource to nodes.
5670        '''
5671        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5672        '''
5673         The path used to check the health of your connection.  Defaults to `default`.
5674        '''
5675        self.healthy = healthy if healthy is not None else False
5676        '''
5677         True if the datasource is reachable and the credentials are valid.
5678        '''
5679        self.hostname = hostname if hostname is not None else ''
5680        self.id = id if id is not None else ''
5681        '''
5682         Unique identifier of the Resource.
5683        '''
5684        self.name = name if name is not None else ''
5685        '''
5686         Unique human-readable name of the Resource.
5687        '''
5688        self.port = port if port is not None else 0
5689        self.port_override = port_override if port_override is not None else 0
5690        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5691        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5692        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5693        '''
5694         ID of the secret store containing credentials for this resource, if any.
5695        '''
5696        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5697        '''
5698         Tags is a map of key, value pairs.
5699        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5721    def to_dict(self):
5722        return {
5723            'bind_interface': self.bind_interface,
5724            'certificate_authority': self.certificate_authority,
5725            'client_certificate': self.client_certificate,
5726            'client_key': self.client_key,
5727            'egress_filter': self.egress_filter,
5728            'healthcheck_namespace': self.healthcheck_namespace,
5729            'healthy': self.healthy,
5730            'hostname': self.hostname,
5731            'id': self.id,
5732            'name': self.name,
5733            'port': self.port,
5734            'port_override': self.port_override,
5735            'remote_identity_group_id': self.remote_identity_group_id,
5736            'remote_identity_healthcheck_username':
5737            self.remote_identity_healthcheck_username,
5738            'secret_store_id': self.secret_store_id,
5739            'tags': self.tags,
5740        }
@classmethod
def from_dict(cls, d)
5742    @classmethod
5743    def from_dict(cls, d):
5744        return cls(
5745            bind_interface=d.get('bind_interface'),
5746            certificate_authority=d.get('certificate_authority'),
5747            client_certificate=d.get('client_certificate'),
5748            client_key=d.get('client_key'),
5749            egress_filter=d.get('egress_filter'),
5750            healthcheck_namespace=d.get('healthcheck_namespace'),
5751            healthy=d.get('healthy'),
5752            hostname=d.get('hostname'),
5753            id=d.get('id'),
5754            name=d.get('name'),
5755            port=d.get('port'),
5756            port_override=d.get('port_override'),
5757            remote_identity_group_id=d.get('remote_identity_group_id'),
5758            remote_identity_healthcheck_username=d.get(
5759                'remote_identity_healthcheck_username'),
5760            secret_store_id=d.get('secret_store_id'),
5761            tags=d.get('tags'),
5762        )
class KubernetesBasicAuth:
5765class KubernetesBasicAuth:
5766    __slots__ = [
5767        'bind_interface',
5768        'egress_filter',
5769        'healthcheck_namespace',
5770        'healthy',
5771        'hostname',
5772        'id',
5773        'name',
5774        'password',
5775        'port',
5776        'port_override',
5777        'secret_store_id',
5778        'tags',
5779        'username',
5780    ]
5781
5782    def __init__(
5783        self,
5784        bind_interface=None,
5785        egress_filter=None,
5786        healthcheck_namespace=None,
5787        healthy=None,
5788        hostname=None,
5789        id=None,
5790        name=None,
5791        password=None,
5792        port=None,
5793        port_override=None,
5794        secret_store_id=None,
5795        tags=None,
5796        username=None,
5797    ):
5798        self.bind_interface = bind_interface if bind_interface is not None else ''
5799        '''
5800         Bind interface
5801        '''
5802        self.egress_filter = egress_filter if egress_filter is not None else ''
5803        '''
5804         A filter applied to the routing logic to pin datasource to nodes.
5805        '''
5806        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5807        '''
5808         The path used to check the health of your connection.  Defaults to `default`.
5809        '''
5810        self.healthy = healthy if healthy is not None else False
5811        '''
5812         True if the datasource is reachable and the credentials are valid.
5813        '''
5814        self.hostname = hostname if hostname is not None else ''
5815        self.id = id if id is not None else ''
5816        '''
5817         Unique identifier of the Resource.
5818        '''
5819        self.name = name if name is not None else ''
5820        '''
5821         Unique human-readable name of the Resource.
5822        '''
5823        self.password = password if password is not None else ''
5824        self.port = port if port is not None else 0
5825        self.port_override = port_override if port_override is not None else 0
5826        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5827        '''
5828         ID of the secret store containing credentials for this resource, if any.
5829        '''
5830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5831        '''
5832         Tags is a map of key, value pairs.
5833        '''
5834        self.username = username if username is not None else ''
5835
5836    def __repr__(self):
5837        return '<sdm.KubernetesBasicAuth ' + \
5838            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5839            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5840            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5841            'healthy: ' + repr(self.healthy) + ' ' +\
5842            'hostname: ' + repr(self.hostname) + ' ' +\
5843            'id: ' + repr(self.id) + ' ' +\
5844            'name: ' + repr(self.name) + ' ' +\
5845            'password: ' + repr(self.password) + ' ' +\
5846            'port: ' + repr(self.port) + ' ' +\
5847            'port_override: ' + repr(self.port_override) + ' ' +\
5848            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5849            'tags: ' + repr(self.tags) + ' ' +\
5850            'username: ' + repr(self.username) + ' ' +\
5851            '>'
5852
5853    def to_dict(self):
5854        return {
5855            'bind_interface': self.bind_interface,
5856            'egress_filter': self.egress_filter,
5857            'healthcheck_namespace': self.healthcheck_namespace,
5858            'healthy': self.healthy,
5859            'hostname': self.hostname,
5860            'id': self.id,
5861            'name': self.name,
5862            'password': self.password,
5863            'port': self.port,
5864            'port_override': self.port_override,
5865            'secret_store_id': self.secret_store_id,
5866            'tags': self.tags,
5867            'username': self.username,
5868        }
5869
5870    @classmethod
5871    def from_dict(cls, d):
5872        return cls(
5873            bind_interface=d.get('bind_interface'),
5874            egress_filter=d.get('egress_filter'),
5875            healthcheck_namespace=d.get('healthcheck_namespace'),
5876            healthy=d.get('healthy'),
5877            hostname=d.get('hostname'),
5878            id=d.get('id'),
5879            name=d.get('name'),
5880            password=d.get('password'),
5881            port=d.get('port'),
5882            port_override=d.get('port_override'),
5883            secret_store_id=d.get('secret_store_id'),
5884            tags=d.get('tags'),
5885            username=d.get('username'),
5886        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5782    def __init__(
5783        self,
5784        bind_interface=None,
5785        egress_filter=None,
5786        healthcheck_namespace=None,
5787        healthy=None,
5788        hostname=None,
5789        id=None,
5790        name=None,
5791        password=None,
5792        port=None,
5793        port_override=None,
5794        secret_store_id=None,
5795        tags=None,
5796        username=None,
5797    ):
5798        self.bind_interface = bind_interface if bind_interface is not None else ''
5799        '''
5800         Bind interface
5801        '''
5802        self.egress_filter = egress_filter if egress_filter is not None else ''
5803        '''
5804         A filter applied to the routing logic to pin datasource to nodes.
5805        '''
5806        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5807        '''
5808         The path used to check the health of your connection.  Defaults to `default`.
5809        '''
5810        self.healthy = healthy if healthy is not None else False
5811        '''
5812         True if the datasource is reachable and the credentials are valid.
5813        '''
5814        self.hostname = hostname if hostname is not None else ''
5815        self.id = id if id is not None else ''
5816        '''
5817         Unique identifier of the Resource.
5818        '''
5819        self.name = name if name is not None else ''
5820        '''
5821         Unique human-readable name of the Resource.
5822        '''
5823        self.password = password if password is not None else ''
5824        self.port = port if port is not None else 0
5825        self.port_override = port_override if port_override is not None else 0
5826        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5827        '''
5828         ID of the secret store containing credentials for this resource, if any.
5829        '''
5830        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5831        '''
5832         Tags is a map of key, value pairs.
5833        '''
5834        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5853    def to_dict(self):
5854        return {
5855            'bind_interface': self.bind_interface,
5856            'egress_filter': self.egress_filter,
5857            'healthcheck_namespace': self.healthcheck_namespace,
5858            'healthy': self.healthy,
5859            'hostname': self.hostname,
5860            'id': self.id,
5861            'name': self.name,
5862            'password': self.password,
5863            'port': self.port,
5864            'port_override': self.port_override,
5865            'secret_store_id': self.secret_store_id,
5866            'tags': self.tags,
5867            'username': self.username,
5868        }
@classmethod
def from_dict(cls, d)
5870    @classmethod
5871    def from_dict(cls, d):
5872        return cls(
5873            bind_interface=d.get('bind_interface'),
5874            egress_filter=d.get('egress_filter'),
5875            healthcheck_namespace=d.get('healthcheck_namespace'),
5876            healthy=d.get('healthy'),
5877            hostname=d.get('hostname'),
5878            id=d.get('id'),
5879            name=d.get('name'),
5880            password=d.get('password'),
5881            port=d.get('port'),
5882            port_override=d.get('port_override'),
5883            secret_store_id=d.get('secret_store_id'),
5884            tags=d.get('tags'),
5885            username=d.get('username'),
5886        )
class KubernetesServiceAccount:
5889class KubernetesServiceAccount:
5890    __slots__ = [
5891        'bind_interface',
5892        'egress_filter',
5893        'healthcheck_namespace',
5894        'healthy',
5895        'hostname',
5896        'id',
5897        'name',
5898        'port',
5899        'port_override',
5900        'remote_identity_group_id',
5901        'remote_identity_healthcheck_username',
5902        'secret_store_id',
5903        'tags',
5904        'token',
5905    ]
5906
5907    def __init__(
5908        self,
5909        bind_interface=None,
5910        egress_filter=None,
5911        healthcheck_namespace=None,
5912        healthy=None,
5913        hostname=None,
5914        id=None,
5915        name=None,
5916        port=None,
5917        port_override=None,
5918        remote_identity_group_id=None,
5919        remote_identity_healthcheck_username=None,
5920        secret_store_id=None,
5921        tags=None,
5922        token=None,
5923    ):
5924        self.bind_interface = bind_interface if bind_interface is not None else ''
5925        '''
5926         Bind interface
5927        '''
5928        self.egress_filter = egress_filter if egress_filter is not None else ''
5929        '''
5930         A filter applied to the routing logic to pin datasource to nodes.
5931        '''
5932        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5933        '''
5934         The path used to check the health of your connection.  Defaults to `default`.
5935        '''
5936        self.healthy = healthy if healthy is not None else False
5937        '''
5938         True if the datasource is reachable and the credentials are valid.
5939        '''
5940        self.hostname = hostname if hostname is not None else ''
5941        self.id = id if id is not None else ''
5942        '''
5943         Unique identifier of the Resource.
5944        '''
5945        self.name = name if name is not None else ''
5946        '''
5947         Unique human-readable name of the Resource.
5948        '''
5949        self.port = port if port is not None else 0
5950        self.port_override = port_override if port_override is not None else 0
5951        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5952        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5953        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5954        '''
5955         ID of the secret store containing credentials for this resource, if any.
5956        '''
5957        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5958        '''
5959         Tags is a map of key, value pairs.
5960        '''
5961        self.token = token if token is not None else ''
5962
5963    def __repr__(self):
5964        return '<sdm.KubernetesServiceAccount ' + \
5965            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5966            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5967            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5968            'healthy: ' + repr(self.healthy) + ' ' +\
5969            'hostname: ' + repr(self.hostname) + ' ' +\
5970            'id: ' + repr(self.id) + ' ' +\
5971            'name: ' + repr(self.name) + ' ' +\
5972            'port: ' + repr(self.port) + ' ' +\
5973            'port_override: ' + repr(self.port_override) + ' ' +\
5974            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5975            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5976            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5977            'tags: ' + repr(self.tags) + ' ' +\
5978            'token: ' + repr(self.token) + ' ' +\
5979            '>'
5980
5981    def to_dict(self):
5982        return {
5983            'bind_interface': self.bind_interface,
5984            'egress_filter': self.egress_filter,
5985            'healthcheck_namespace': self.healthcheck_namespace,
5986            'healthy': self.healthy,
5987            'hostname': self.hostname,
5988            'id': self.id,
5989            'name': self.name,
5990            'port': self.port,
5991            'port_override': self.port_override,
5992            'remote_identity_group_id': self.remote_identity_group_id,
5993            'remote_identity_healthcheck_username':
5994            self.remote_identity_healthcheck_username,
5995            'secret_store_id': self.secret_store_id,
5996            'tags': self.tags,
5997            'token': self.token,
5998        }
5999
6000    @classmethod
6001    def from_dict(cls, d):
6002        return cls(
6003            bind_interface=d.get('bind_interface'),
6004            egress_filter=d.get('egress_filter'),
6005            healthcheck_namespace=d.get('healthcheck_namespace'),
6006            healthy=d.get('healthy'),
6007            hostname=d.get('hostname'),
6008            id=d.get('id'),
6009            name=d.get('name'),
6010            port=d.get('port'),
6011            port_override=d.get('port_override'),
6012            remote_identity_group_id=d.get('remote_identity_group_id'),
6013            remote_identity_healthcheck_username=d.get(
6014                'remote_identity_healthcheck_username'),
6015            secret_store_id=d.get('secret_store_id'),
6016            tags=d.get('tags'),
6017            token=d.get('token'),
6018        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
5907    def __init__(
5908        self,
5909        bind_interface=None,
5910        egress_filter=None,
5911        healthcheck_namespace=None,
5912        healthy=None,
5913        hostname=None,
5914        id=None,
5915        name=None,
5916        port=None,
5917        port_override=None,
5918        remote_identity_group_id=None,
5919        remote_identity_healthcheck_username=None,
5920        secret_store_id=None,
5921        tags=None,
5922        token=None,
5923    ):
5924        self.bind_interface = bind_interface if bind_interface is not None else ''
5925        '''
5926         Bind interface
5927        '''
5928        self.egress_filter = egress_filter if egress_filter is not None else ''
5929        '''
5930         A filter applied to the routing logic to pin datasource to nodes.
5931        '''
5932        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5933        '''
5934         The path used to check the health of your connection.  Defaults to `default`.
5935        '''
5936        self.healthy = healthy if healthy is not None else False
5937        '''
5938         True if the datasource is reachable and the credentials are valid.
5939        '''
5940        self.hostname = hostname if hostname is not None else ''
5941        self.id = id if id is not None else ''
5942        '''
5943         Unique identifier of the Resource.
5944        '''
5945        self.name = name if name is not None else ''
5946        '''
5947         Unique human-readable name of the Resource.
5948        '''
5949        self.port = port if port is not None else 0
5950        self.port_override = port_override if port_override is not None else 0
5951        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5952        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5953        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5954        '''
5955         ID of the secret store containing credentials for this resource, if any.
5956        '''
5957        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5958        '''
5959         Tags is a map of key, value pairs.
5960        '''
5961        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
5981    def to_dict(self):
5982        return {
5983            'bind_interface': self.bind_interface,
5984            'egress_filter': self.egress_filter,
5985            'healthcheck_namespace': self.healthcheck_namespace,
5986            'healthy': self.healthy,
5987            'hostname': self.hostname,
5988            'id': self.id,
5989            'name': self.name,
5990            'port': self.port,
5991            'port_override': self.port_override,
5992            'remote_identity_group_id': self.remote_identity_group_id,
5993            'remote_identity_healthcheck_username':
5994            self.remote_identity_healthcheck_username,
5995            'secret_store_id': self.secret_store_id,
5996            'tags': self.tags,
5997            'token': self.token,
5998        }
@classmethod
def from_dict(cls, d)
6000    @classmethod
6001    def from_dict(cls, d):
6002        return cls(
6003            bind_interface=d.get('bind_interface'),
6004            egress_filter=d.get('egress_filter'),
6005            healthcheck_namespace=d.get('healthcheck_namespace'),
6006            healthy=d.get('healthy'),
6007            hostname=d.get('hostname'),
6008            id=d.get('id'),
6009            name=d.get('name'),
6010            port=d.get('port'),
6011            port_override=d.get('port_override'),
6012            remote_identity_group_id=d.get('remote_identity_group_id'),
6013            remote_identity_healthcheck_username=d.get(
6014                'remote_identity_healthcheck_username'),
6015            secret_store_id=d.get('secret_store_id'),
6016            tags=d.get('tags'),
6017            token=d.get('token'),
6018        )
class KubernetesServiceAccountUserImpersonation:
6021class KubernetesServiceAccountUserImpersonation:
6022    __slots__ = [
6023        'bind_interface',
6024        'egress_filter',
6025        'healthcheck_namespace',
6026        'healthy',
6027        'hostname',
6028        'id',
6029        'name',
6030        'port',
6031        'port_override',
6032        'secret_store_id',
6033        'tags',
6034        'token',
6035    ]
6036
6037    def __init__(
6038        self,
6039        bind_interface=None,
6040        egress_filter=None,
6041        healthcheck_namespace=None,
6042        healthy=None,
6043        hostname=None,
6044        id=None,
6045        name=None,
6046        port=None,
6047        port_override=None,
6048        secret_store_id=None,
6049        tags=None,
6050        token=None,
6051    ):
6052        self.bind_interface = bind_interface if bind_interface is not None else ''
6053        '''
6054         Bind interface
6055        '''
6056        self.egress_filter = egress_filter if egress_filter is not None else ''
6057        '''
6058         A filter applied to the routing logic to pin datasource to nodes.
6059        '''
6060        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6061        '''
6062         The path used to check the health of your connection.  Defaults to `default`.
6063        '''
6064        self.healthy = healthy if healthy is not None else False
6065        '''
6066         True if the datasource is reachable and the credentials are valid.
6067        '''
6068        self.hostname = hostname if hostname is not None else ''
6069        self.id = id if id is not None else ''
6070        '''
6071         Unique identifier of the Resource.
6072        '''
6073        self.name = name if name is not None else ''
6074        '''
6075         Unique human-readable name of the Resource.
6076        '''
6077        self.port = port if port is not None else 0
6078        self.port_override = port_override if port_override is not None else 0
6079        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6080        '''
6081         ID of the secret store containing credentials for this resource, if any.
6082        '''
6083        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6084        '''
6085         Tags is a map of key, value pairs.
6086        '''
6087        self.token = token if token is not None else ''
6088
6089    def __repr__(self):
6090        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6091            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6092            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6093            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6094            'healthy: ' + repr(self.healthy) + ' ' +\
6095            'hostname: ' + repr(self.hostname) + ' ' +\
6096            'id: ' + repr(self.id) + ' ' +\
6097            'name: ' + repr(self.name) + ' ' +\
6098            'port: ' + repr(self.port) + ' ' +\
6099            'port_override: ' + repr(self.port_override) + ' ' +\
6100            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6101            'tags: ' + repr(self.tags) + ' ' +\
6102            'token: ' + repr(self.token) + ' ' +\
6103            '>'
6104
6105    def to_dict(self):
6106        return {
6107            'bind_interface': self.bind_interface,
6108            'egress_filter': self.egress_filter,
6109            'healthcheck_namespace': self.healthcheck_namespace,
6110            'healthy': self.healthy,
6111            'hostname': self.hostname,
6112            'id': self.id,
6113            'name': self.name,
6114            'port': self.port,
6115            'port_override': self.port_override,
6116            'secret_store_id': self.secret_store_id,
6117            'tags': self.tags,
6118            'token': self.token,
6119        }
6120
6121    @classmethod
6122    def from_dict(cls, d):
6123        return cls(
6124            bind_interface=d.get('bind_interface'),
6125            egress_filter=d.get('egress_filter'),
6126            healthcheck_namespace=d.get('healthcheck_namespace'),
6127            healthy=d.get('healthy'),
6128            hostname=d.get('hostname'),
6129            id=d.get('id'),
6130            name=d.get('name'),
6131            port=d.get('port'),
6132            port_override=d.get('port_override'),
6133            secret_store_id=d.get('secret_store_id'),
6134            tags=d.get('tags'),
6135            token=d.get('token'),
6136        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
6037    def __init__(
6038        self,
6039        bind_interface=None,
6040        egress_filter=None,
6041        healthcheck_namespace=None,
6042        healthy=None,
6043        hostname=None,
6044        id=None,
6045        name=None,
6046        port=None,
6047        port_override=None,
6048        secret_store_id=None,
6049        tags=None,
6050        token=None,
6051    ):
6052        self.bind_interface = bind_interface if bind_interface is not None else ''
6053        '''
6054         Bind interface
6055        '''
6056        self.egress_filter = egress_filter if egress_filter is not None else ''
6057        '''
6058         A filter applied to the routing logic to pin datasource to nodes.
6059        '''
6060        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6061        '''
6062         The path used to check the health of your connection.  Defaults to `default`.
6063        '''
6064        self.healthy = healthy if healthy is not None else False
6065        '''
6066         True if the datasource is reachable and the credentials are valid.
6067        '''
6068        self.hostname = hostname if hostname is not None else ''
6069        self.id = id if id is not None else ''
6070        '''
6071         Unique identifier of the Resource.
6072        '''
6073        self.name = name if name is not None else ''
6074        '''
6075         Unique human-readable name of the Resource.
6076        '''
6077        self.port = port if port is not None else 0
6078        self.port_override = port_override if port_override is not None else 0
6079        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6080        '''
6081         ID of the secret store containing credentials for this resource, if any.
6082        '''
6083        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6084        '''
6085         Tags is a map of key, value pairs.
6086        '''
6087        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6105    def to_dict(self):
6106        return {
6107            'bind_interface': self.bind_interface,
6108            'egress_filter': self.egress_filter,
6109            'healthcheck_namespace': self.healthcheck_namespace,
6110            'healthy': self.healthy,
6111            'hostname': self.hostname,
6112            'id': self.id,
6113            'name': self.name,
6114            'port': self.port,
6115            'port_override': self.port_override,
6116            'secret_store_id': self.secret_store_id,
6117            'tags': self.tags,
6118            'token': self.token,
6119        }
@classmethod
def from_dict(cls, d)
6121    @classmethod
6122    def from_dict(cls, d):
6123        return cls(
6124            bind_interface=d.get('bind_interface'),
6125            egress_filter=d.get('egress_filter'),
6126            healthcheck_namespace=d.get('healthcheck_namespace'),
6127            healthy=d.get('healthy'),
6128            hostname=d.get('hostname'),
6129            id=d.get('id'),
6130            name=d.get('name'),
6131            port=d.get('port'),
6132            port_override=d.get('port_override'),
6133            secret_store_id=d.get('secret_store_id'),
6134            tags=d.get('tags'),
6135            token=d.get('token'),
6136        )
class KubernetesUserImpersonation:
6139class KubernetesUserImpersonation:
6140    __slots__ = [
6141        'bind_interface',
6142        'certificate_authority',
6143        'client_certificate',
6144        'client_key',
6145        'egress_filter',
6146        'healthcheck_namespace',
6147        'healthy',
6148        'hostname',
6149        'id',
6150        'name',
6151        'port',
6152        'port_override',
6153        'secret_store_id',
6154        'tags',
6155    ]
6156
6157    def __init__(
6158        self,
6159        bind_interface=None,
6160        certificate_authority=None,
6161        client_certificate=None,
6162        client_key=None,
6163        egress_filter=None,
6164        healthcheck_namespace=None,
6165        healthy=None,
6166        hostname=None,
6167        id=None,
6168        name=None,
6169        port=None,
6170        port_override=None,
6171        secret_store_id=None,
6172        tags=None,
6173    ):
6174        self.bind_interface = bind_interface if bind_interface is not None else ''
6175        '''
6176         Bind interface
6177        '''
6178        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6179        self.client_certificate = client_certificate if client_certificate is not None else ''
6180        self.client_key = client_key if client_key is not None else ''
6181        self.egress_filter = egress_filter if egress_filter is not None else ''
6182        '''
6183         A filter applied to the routing logic to pin datasource to nodes.
6184        '''
6185        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6186        '''
6187         The path used to check the health of your connection.  Defaults to `default`.
6188        '''
6189        self.healthy = healthy if healthy is not None else False
6190        '''
6191         True if the datasource is reachable and the credentials are valid.
6192        '''
6193        self.hostname = hostname if hostname is not None else ''
6194        self.id = id if id is not None else ''
6195        '''
6196         Unique identifier of the Resource.
6197        '''
6198        self.name = name if name is not None else ''
6199        '''
6200         Unique human-readable name of the Resource.
6201        '''
6202        self.port = port if port is not None else 0
6203        self.port_override = port_override if port_override is not None else 0
6204        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6205        '''
6206         ID of the secret store containing credentials for this resource, if any.
6207        '''
6208        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6209        '''
6210         Tags is a map of key, value pairs.
6211        '''
6212
6213    def __repr__(self):
6214        return '<sdm.KubernetesUserImpersonation ' + \
6215            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6216            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6217            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6218            'client_key: ' + repr(self.client_key) + ' ' +\
6219            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6220            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6221            'healthy: ' + repr(self.healthy) + ' ' +\
6222            'hostname: ' + repr(self.hostname) + ' ' +\
6223            'id: ' + repr(self.id) + ' ' +\
6224            'name: ' + repr(self.name) + ' ' +\
6225            'port: ' + repr(self.port) + ' ' +\
6226            'port_override: ' + repr(self.port_override) + ' ' +\
6227            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6228            'tags: ' + repr(self.tags) + ' ' +\
6229            '>'
6230
6231    def to_dict(self):
6232        return {
6233            'bind_interface': self.bind_interface,
6234            'certificate_authority': self.certificate_authority,
6235            'client_certificate': self.client_certificate,
6236            'client_key': self.client_key,
6237            'egress_filter': self.egress_filter,
6238            'healthcheck_namespace': self.healthcheck_namespace,
6239            'healthy': self.healthy,
6240            'hostname': self.hostname,
6241            'id': self.id,
6242            'name': self.name,
6243            'port': self.port,
6244            'port_override': self.port_override,
6245            'secret_store_id': self.secret_store_id,
6246            'tags': self.tags,
6247        }
6248
6249    @classmethod
6250    def from_dict(cls, d):
6251        return cls(
6252            bind_interface=d.get('bind_interface'),
6253            certificate_authority=d.get('certificate_authority'),
6254            client_certificate=d.get('client_certificate'),
6255            client_key=d.get('client_key'),
6256            egress_filter=d.get('egress_filter'),
6257            healthcheck_namespace=d.get('healthcheck_namespace'),
6258            healthy=d.get('healthy'),
6259            hostname=d.get('hostname'),
6260            id=d.get('id'),
6261            name=d.get('name'),
6262            port=d.get('port'),
6263            port_override=d.get('port_override'),
6264            secret_store_id=d.get('secret_store_id'),
6265            tags=d.get('tags'),
6266        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6157    def __init__(
6158        self,
6159        bind_interface=None,
6160        certificate_authority=None,
6161        client_certificate=None,
6162        client_key=None,
6163        egress_filter=None,
6164        healthcheck_namespace=None,
6165        healthy=None,
6166        hostname=None,
6167        id=None,
6168        name=None,
6169        port=None,
6170        port_override=None,
6171        secret_store_id=None,
6172        tags=None,
6173    ):
6174        self.bind_interface = bind_interface if bind_interface is not None else ''
6175        '''
6176         Bind interface
6177        '''
6178        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6179        self.client_certificate = client_certificate if client_certificate is not None else ''
6180        self.client_key = client_key if client_key is not None else ''
6181        self.egress_filter = egress_filter if egress_filter is not None else ''
6182        '''
6183         A filter applied to the routing logic to pin datasource to nodes.
6184        '''
6185        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6186        '''
6187         The path used to check the health of your connection.  Defaults to `default`.
6188        '''
6189        self.healthy = healthy if healthy is not None else False
6190        '''
6191         True if the datasource is reachable and the credentials are valid.
6192        '''
6193        self.hostname = hostname if hostname is not None else ''
6194        self.id = id if id is not None else ''
6195        '''
6196         Unique identifier of the Resource.
6197        '''
6198        self.name = name if name is not None else ''
6199        '''
6200         Unique human-readable name of the Resource.
6201        '''
6202        self.port = port if port is not None else 0
6203        self.port_override = port_override if port_override is not None else 0
6204        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6205        '''
6206         ID of the secret store containing credentials for this resource, if any.
6207        '''
6208        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6209        '''
6210         Tags is a map of key, value pairs.
6211        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6231    def to_dict(self):
6232        return {
6233            'bind_interface': self.bind_interface,
6234            'certificate_authority': self.certificate_authority,
6235            'client_certificate': self.client_certificate,
6236            'client_key': self.client_key,
6237            'egress_filter': self.egress_filter,
6238            'healthcheck_namespace': self.healthcheck_namespace,
6239            'healthy': self.healthy,
6240            'hostname': self.hostname,
6241            'id': self.id,
6242            'name': self.name,
6243            'port': self.port,
6244            'port_override': self.port_override,
6245            'secret_store_id': self.secret_store_id,
6246            'tags': self.tags,
6247        }
@classmethod
def from_dict(cls, d)
6249    @classmethod
6250    def from_dict(cls, d):
6251        return cls(
6252            bind_interface=d.get('bind_interface'),
6253            certificate_authority=d.get('certificate_authority'),
6254            client_certificate=d.get('client_certificate'),
6255            client_key=d.get('client_key'),
6256            egress_filter=d.get('egress_filter'),
6257            healthcheck_namespace=d.get('healthcheck_namespace'),
6258            healthy=d.get('healthy'),
6259            hostname=d.get('hostname'),
6260            id=d.get('id'),
6261            name=d.get('name'),
6262            port=d.get('port'),
6263            port_override=d.get('port_override'),
6264            secret_store_id=d.get('secret_store_id'),
6265            tags=d.get('tags'),
6266        )
class MTLSMysql:
6269class MTLSMysql:
6270    '''
6271    MTLSMysql is currently unstable, and its API may change, or it may be removed,
6272    without a major version bump.
6273    '''
6274    __slots__ = [
6275        'bind_interface',
6276        'certificate_authority',
6277        'client_certificate',
6278        'client_key',
6279        'database',
6280        'egress_filter',
6281        'healthy',
6282        'hostname',
6283        'id',
6284        'name',
6285        'password',
6286        'port',
6287        'port_override',
6288        'secret_store_id',
6289        'server_name',
6290        'tags',
6291        'username',
6292    ]
6293
6294    def __init__(
6295        self,
6296        bind_interface=None,
6297        certificate_authority=None,
6298        client_certificate=None,
6299        client_key=None,
6300        database=None,
6301        egress_filter=None,
6302        healthy=None,
6303        hostname=None,
6304        id=None,
6305        name=None,
6306        password=None,
6307        port=None,
6308        port_override=None,
6309        secret_store_id=None,
6310        server_name=None,
6311        tags=None,
6312        username=None,
6313    ):
6314        self.bind_interface = bind_interface if bind_interface is not None else ''
6315        '''
6316         Bind interface
6317        '''
6318        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6319        self.client_certificate = client_certificate if client_certificate is not None else ''
6320        self.client_key = client_key if client_key is not None else ''
6321        self.database = database if database is not None else ''
6322        self.egress_filter = egress_filter if egress_filter is not None else ''
6323        '''
6324         A filter applied to the routing logic to pin datasource to nodes.
6325        '''
6326        self.healthy = healthy if healthy is not None else False
6327        '''
6328         True if the datasource is reachable and the credentials are valid.
6329        '''
6330        self.hostname = hostname if hostname is not None else ''
6331        self.id = id if id is not None else ''
6332        '''
6333         Unique identifier of the Resource.
6334        '''
6335        self.name = name if name is not None else ''
6336        '''
6337         Unique human-readable name of the Resource.
6338        '''
6339        self.password = password if password is not None else ''
6340        self.port = port if port is not None else 0
6341        self.port_override = port_override if port_override is not None else 0
6342        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6343        '''
6344         ID of the secret store containing credentials for this resource, if any.
6345        '''
6346        self.server_name = server_name if server_name is not None else ''
6347        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6348        '''
6349         Tags is a map of key, value pairs.
6350        '''
6351        self.username = username if username is not None else ''
6352
6353    def __repr__(self):
6354        return '<sdm.MTLSMysql ' + \
6355            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6356            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6357            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6358            'client_key: ' + repr(self.client_key) + ' ' +\
6359            'database: ' + repr(self.database) + ' ' +\
6360            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6361            'healthy: ' + repr(self.healthy) + ' ' +\
6362            'hostname: ' + repr(self.hostname) + ' ' +\
6363            'id: ' + repr(self.id) + ' ' +\
6364            'name: ' + repr(self.name) + ' ' +\
6365            'password: ' + repr(self.password) + ' ' +\
6366            'port: ' + repr(self.port) + ' ' +\
6367            'port_override: ' + repr(self.port_override) + ' ' +\
6368            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6369            'server_name: ' + repr(self.server_name) + ' ' +\
6370            'tags: ' + repr(self.tags) + ' ' +\
6371            'username: ' + repr(self.username) + ' ' +\
6372            '>'
6373
6374    def to_dict(self):
6375        return {
6376            'bind_interface': self.bind_interface,
6377            'certificate_authority': self.certificate_authority,
6378            'client_certificate': self.client_certificate,
6379            'client_key': self.client_key,
6380            'database': self.database,
6381            'egress_filter': self.egress_filter,
6382            'healthy': self.healthy,
6383            'hostname': self.hostname,
6384            'id': self.id,
6385            'name': self.name,
6386            'password': self.password,
6387            'port': self.port,
6388            'port_override': self.port_override,
6389            'secret_store_id': self.secret_store_id,
6390            'server_name': self.server_name,
6391            'tags': self.tags,
6392            'username': self.username,
6393        }
6394
6395    @classmethod
6396    def from_dict(cls, d):
6397        return cls(
6398            bind_interface=d.get('bind_interface'),
6399            certificate_authority=d.get('certificate_authority'),
6400            client_certificate=d.get('client_certificate'),
6401            client_key=d.get('client_key'),
6402            database=d.get('database'),
6403            egress_filter=d.get('egress_filter'),
6404            healthy=d.get('healthy'),
6405            hostname=d.get('hostname'),
6406            id=d.get('id'),
6407            name=d.get('name'),
6408            password=d.get('password'),
6409            port=d.get('port'),
6410            port_override=d.get('port_override'),
6411            secret_store_id=d.get('secret_store_id'),
6412            server_name=d.get('server_name'),
6413            tags=d.get('tags'),
6414            username=d.get('username'),
6415        )

MTLSMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6294    def __init__(
6295        self,
6296        bind_interface=None,
6297        certificate_authority=None,
6298        client_certificate=None,
6299        client_key=None,
6300        database=None,
6301        egress_filter=None,
6302        healthy=None,
6303        hostname=None,
6304        id=None,
6305        name=None,
6306        password=None,
6307        port=None,
6308        port_override=None,
6309        secret_store_id=None,
6310        server_name=None,
6311        tags=None,
6312        username=None,
6313    ):
6314        self.bind_interface = bind_interface if bind_interface is not None else ''
6315        '''
6316         Bind interface
6317        '''
6318        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6319        self.client_certificate = client_certificate if client_certificate is not None else ''
6320        self.client_key = client_key if client_key is not None else ''
6321        self.database = database if database is not None else ''
6322        self.egress_filter = egress_filter if egress_filter is not None else ''
6323        '''
6324         A filter applied to the routing logic to pin datasource to nodes.
6325        '''
6326        self.healthy = healthy if healthy is not None else False
6327        '''
6328         True if the datasource is reachable and the credentials are valid.
6329        '''
6330        self.hostname = hostname if hostname is not None else ''
6331        self.id = id if id is not None else ''
6332        '''
6333         Unique identifier of the Resource.
6334        '''
6335        self.name = name if name is not None else ''
6336        '''
6337         Unique human-readable name of the Resource.
6338        '''
6339        self.password = password if password is not None else ''
6340        self.port = port if port is not None else 0
6341        self.port_override = port_override if port_override is not None else 0
6342        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6343        '''
6344         ID of the secret store containing credentials for this resource, if any.
6345        '''
6346        self.server_name = server_name if server_name is not None else ''
6347        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6348        '''
6349         Tags is a map of key, value pairs.
6350        '''
6351        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6374    def to_dict(self):
6375        return {
6376            'bind_interface': self.bind_interface,
6377            'certificate_authority': self.certificate_authority,
6378            'client_certificate': self.client_certificate,
6379            'client_key': self.client_key,
6380            'database': self.database,
6381            'egress_filter': self.egress_filter,
6382            'healthy': self.healthy,
6383            'hostname': self.hostname,
6384            'id': self.id,
6385            'name': self.name,
6386            'password': self.password,
6387            'port': self.port,
6388            'port_override': self.port_override,
6389            'secret_store_id': self.secret_store_id,
6390            'server_name': self.server_name,
6391            'tags': self.tags,
6392            'username': self.username,
6393        }
@classmethod
def from_dict(cls, d)
6395    @classmethod
6396    def from_dict(cls, d):
6397        return cls(
6398            bind_interface=d.get('bind_interface'),
6399            certificate_authority=d.get('certificate_authority'),
6400            client_certificate=d.get('client_certificate'),
6401            client_key=d.get('client_key'),
6402            database=d.get('database'),
6403            egress_filter=d.get('egress_filter'),
6404            healthy=d.get('healthy'),
6405            hostname=d.get('hostname'),
6406            id=d.get('id'),
6407            name=d.get('name'),
6408            password=d.get('password'),
6409            port=d.get('port'),
6410            port_override=d.get('port_override'),
6411            secret_store_id=d.get('secret_store_id'),
6412            server_name=d.get('server_name'),
6413            tags=d.get('tags'),
6414            username=d.get('username'),
6415        )
class MTLSPostgres:
6418class MTLSPostgres:
6419    __slots__ = [
6420        'bind_interface',
6421        'certificate_authority',
6422        'client_certificate',
6423        'client_key',
6424        'database',
6425        'egress_filter',
6426        'healthy',
6427        'hostname',
6428        'id',
6429        'name',
6430        'override_database',
6431        'password',
6432        'port',
6433        'port_override',
6434        'secret_store_id',
6435        'server_name',
6436        'tags',
6437        'username',
6438    ]
6439
6440    def __init__(
6441        self,
6442        bind_interface=None,
6443        certificate_authority=None,
6444        client_certificate=None,
6445        client_key=None,
6446        database=None,
6447        egress_filter=None,
6448        healthy=None,
6449        hostname=None,
6450        id=None,
6451        name=None,
6452        override_database=None,
6453        password=None,
6454        port=None,
6455        port_override=None,
6456        secret_store_id=None,
6457        server_name=None,
6458        tags=None,
6459        username=None,
6460    ):
6461        self.bind_interface = bind_interface if bind_interface is not None else ''
6462        '''
6463         Bind interface
6464        '''
6465        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6466        self.client_certificate = client_certificate if client_certificate is not None else ''
6467        self.client_key = client_key if client_key is not None else ''
6468        self.database = database if database is not None else ''
6469        self.egress_filter = egress_filter if egress_filter is not None else ''
6470        '''
6471         A filter applied to the routing logic to pin datasource to nodes.
6472        '''
6473        self.healthy = healthy if healthy is not None else False
6474        '''
6475         True if the datasource is reachable and the credentials are valid.
6476        '''
6477        self.hostname = hostname if hostname is not None else ''
6478        self.id = id if id is not None else ''
6479        '''
6480         Unique identifier of the Resource.
6481        '''
6482        self.name = name if name is not None else ''
6483        '''
6484         Unique human-readable name of the Resource.
6485        '''
6486        self.override_database = override_database if override_database is not None else False
6487        self.password = password if password is not None else ''
6488        self.port = port if port is not None else 0
6489        self.port_override = port_override if port_override is not None else 0
6490        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6491        '''
6492         ID of the secret store containing credentials for this resource, if any.
6493        '''
6494        self.server_name = server_name if server_name is not None else ''
6495        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6496        '''
6497         Tags is a map of key, value pairs.
6498        '''
6499        self.username = username if username is not None else ''
6500
6501    def __repr__(self):
6502        return '<sdm.MTLSPostgres ' + \
6503            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6504            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6505            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6506            'client_key: ' + repr(self.client_key) + ' ' +\
6507            'database: ' + repr(self.database) + ' ' +\
6508            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6509            'healthy: ' + repr(self.healthy) + ' ' +\
6510            'hostname: ' + repr(self.hostname) + ' ' +\
6511            'id: ' + repr(self.id) + ' ' +\
6512            'name: ' + repr(self.name) + ' ' +\
6513            'override_database: ' + repr(self.override_database) + ' ' +\
6514            'password: ' + repr(self.password) + ' ' +\
6515            'port: ' + repr(self.port) + ' ' +\
6516            'port_override: ' + repr(self.port_override) + ' ' +\
6517            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6518            'server_name: ' + repr(self.server_name) + ' ' +\
6519            'tags: ' + repr(self.tags) + ' ' +\
6520            'username: ' + repr(self.username) + ' ' +\
6521            '>'
6522
6523    def to_dict(self):
6524        return {
6525            'bind_interface': self.bind_interface,
6526            'certificate_authority': self.certificate_authority,
6527            'client_certificate': self.client_certificate,
6528            'client_key': self.client_key,
6529            'database': self.database,
6530            'egress_filter': self.egress_filter,
6531            'healthy': self.healthy,
6532            'hostname': self.hostname,
6533            'id': self.id,
6534            'name': self.name,
6535            'override_database': self.override_database,
6536            'password': self.password,
6537            'port': self.port,
6538            'port_override': self.port_override,
6539            'secret_store_id': self.secret_store_id,
6540            'server_name': self.server_name,
6541            'tags': self.tags,
6542            'username': self.username,
6543        }
6544
6545    @classmethod
6546    def from_dict(cls, d):
6547        return cls(
6548            bind_interface=d.get('bind_interface'),
6549            certificate_authority=d.get('certificate_authority'),
6550            client_certificate=d.get('client_certificate'),
6551            client_key=d.get('client_key'),
6552            database=d.get('database'),
6553            egress_filter=d.get('egress_filter'),
6554            healthy=d.get('healthy'),
6555            hostname=d.get('hostname'),
6556            id=d.get('id'),
6557            name=d.get('name'),
6558            override_database=d.get('override_database'),
6559            password=d.get('password'),
6560            port=d.get('port'),
6561            port_override=d.get('port_override'),
6562            secret_store_id=d.get('secret_store_id'),
6563            server_name=d.get('server_name'),
6564            tags=d.get('tags'),
6565            username=d.get('username'),
6566        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6440    def __init__(
6441        self,
6442        bind_interface=None,
6443        certificate_authority=None,
6444        client_certificate=None,
6445        client_key=None,
6446        database=None,
6447        egress_filter=None,
6448        healthy=None,
6449        hostname=None,
6450        id=None,
6451        name=None,
6452        override_database=None,
6453        password=None,
6454        port=None,
6455        port_override=None,
6456        secret_store_id=None,
6457        server_name=None,
6458        tags=None,
6459        username=None,
6460    ):
6461        self.bind_interface = bind_interface if bind_interface is not None else ''
6462        '''
6463         Bind interface
6464        '''
6465        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6466        self.client_certificate = client_certificate if client_certificate is not None else ''
6467        self.client_key = client_key if client_key is not None else ''
6468        self.database = database if database is not None else ''
6469        self.egress_filter = egress_filter if egress_filter is not None else ''
6470        '''
6471         A filter applied to the routing logic to pin datasource to nodes.
6472        '''
6473        self.healthy = healthy if healthy is not None else False
6474        '''
6475         True if the datasource is reachable and the credentials are valid.
6476        '''
6477        self.hostname = hostname if hostname is not None else ''
6478        self.id = id if id is not None else ''
6479        '''
6480         Unique identifier of the Resource.
6481        '''
6482        self.name = name if name is not None else ''
6483        '''
6484         Unique human-readable name of the Resource.
6485        '''
6486        self.override_database = override_database if override_database is not None else False
6487        self.password = password if password is not None else ''
6488        self.port = port if port is not None else 0
6489        self.port_override = port_override if port_override is not None else 0
6490        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6491        '''
6492         ID of the secret store containing credentials for this resource, if any.
6493        '''
6494        self.server_name = server_name if server_name is not None else ''
6495        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6496        '''
6497         Tags is a map of key, value pairs.
6498        '''
6499        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6523    def to_dict(self):
6524        return {
6525            'bind_interface': self.bind_interface,
6526            'certificate_authority': self.certificate_authority,
6527            'client_certificate': self.client_certificate,
6528            'client_key': self.client_key,
6529            'database': self.database,
6530            'egress_filter': self.egress_filter,
6531            'healthy': self.healthy,
6532            'hostname': self.hostname,
6533            'id': self.id,
6534            'name': self.name,
6535            'override_database': self.override_database,
6536            'password': self.password,
6537            'port': self.port,
6538            'port_override': self.port_override,
6539            'secret_store_id': self.secret_store_id,
6540            'server_name': self.server_name,
6541            'tags': self.tags,
6542            'username': self.username,
6543        }
@classmethod
def from_dict(cls, d)
6545    @classmethod
6546    def from_dict(cls, d):
6547        return cls(
6548            bind_interface=d.get('bind_interface'),
6549            certificate_authority=d.get('certificate_authority'),
6550            client_certificate=d.get('client_certificate'),
6551            client_key=d.get('client_key'),
6552            database=d.get('database'),
6553            egress_filter=d.get('egress_filter'),
6554            healthy=d.get('healthy'),
6555            hostname=d.get('hostname'),
6556            id=d.get('id'),
6557            name=d.get('name'),
6558            override_database=d.get('override_database'),
6559            password=d.get('password'),
6560            port=d.get('port'),
6561            port_override=d.get('port_override'),
6562            secret_store_id=d.get('secret_store_id'),
6563            server_name=d.get('server_name'),
6564            tags=d.get('tags'),
6565            username=d.get('username'),
6566        )
class Maria:
6569class Maria:
6570    __slots__ = [
6571        'bind_interface',
6572        'database',
6573        'egress_filter',
6574        'healthy',
6575        'hostname',
6576        'id',
6577        'name',
6578        'password',
6579        'port',
6580        'port_override',
6581        'secret_store_id',
6582        'tags',
6583        'username',
6584    ]
6585
6586    def __init__(
6587        self,
6588        bind_interface=None,
6589        database=None,
6590        egress_filter=None,
6591        healthy=None,
6592        hostname=None,
6593        id=None,
6594        name=None,
6595        password=None,
6596        port=None,
6597        port_override=None,
6598        secret_store_id=None,
6599        tags=None,
6600        username=None,
6601    ):
6602        self.bind_interface = bind_interface if bind_interface is not None else ''
6603        '''
6604         Bind interface
6605        '''
6606        self.database = database if database is not None else ''
6607        self.egress_filter = egress_filter if egress_filter is not None else ''
6608        '''
6609         A filter applied to the routing logic to pin datasource to nodes.
6610        '''
6611        self.healthy = healthy if healthy is not None else False
6612        '''
6613         True if the datasource is reachable and the credentials are valid.
6614        '''
6615        self.hostname = hostname if hostname is not None else ''
6616        self.id = id if id is not None else ''
6617        '''
6618         Unique identifier of the Resource.
6619        '''
6620        self.name = name if name is not None else ''
6621        '''
6622         Unique human-readable name of the Resource.
6623        '''
6624        self.password = password if password is not None else ''
6625        self.port = port if port is not None else 0
6626        self.port_override = port_override if port_override is not None else 0
6627        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6628        '''
6629         ID of the secret store containing credentials for this resource, if any.
6630        '''
6631        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6632        '''
6633         Tags is a map of key, value pairs.
6634        '''
6635        self.username = username if username is not None else ''
6636
6637    def __repr__(self):
6638        return '<sdm.Maria ' + \
6639            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6640            'database: ' + repr(self.database) + ' ' +\
6641            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6642            'healthy: ' + repr(self.healthy) + ' ' +\
6643            'hostname: ' + repr(self.hostname) + ' ' +\
6644            'id: ' + repr(self.id) + ' ' +\
6645            'name: ' + repr(self.name) + ' ' +\
6646            'password: ' + repr(self.password) + ' ' +\
6647            'port: ' + repr(self.port) + ' ' +\
6648            'port_override: ' + repr(self.port_override) + ' ' +\
6649            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6650            'tags: ' + repr(self.tags) + ' ' +\
6651            'username: ' + repr(self.username) + ' ' +\
6652            '>'
6653
6654    def to_dict(self):
6655        return {
6656            'bind_interface': self.bind_interface,
6657            'database': self.database,
6658            'egress_filter': self.egress_filter,
6659            'healthy': self.healthy,
6660            'hostname': self.hostname,
6661            'id': self.id,
6662            'name': self.name,
6663            'password': self.password,
6664            'port': self.port,
6665            'port_override': self.port_override,
6666            'secret_store_id': self.secret_store_id,
6667            'tags': self.tags,
6668            'username': self.username,
6669        }
6670
6671    @classmethod
6672    def from_dict(cls, d):
6673        return cls(
6674            bind_interface=d.get('bind_interface'),
6675            database=d.get('database'),
6676            egress_filter=d.get('egress_filter'),
6677            healthy=d.get('healthy'),
6678            hostname=d.get('hostname'),
6679            id=d.get('id'),
6680            name=d.get('name'),
6681            password=d.get('password'),
6682            port=d.get('port'),
6683            port_override=d.get('port_override'),
6684            secret_store_id=d.get('secret_store_id'),
6685            tags=d.get('tags'),
6686            username=d.get('username'),
6687        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6586    def __init__(
6587        self,
6588        bind_interface=None,
6589        database=None,
6590        egress_filter=None,
6591        healthy=None,
6592        hostname=None,
6593        id=None,
6594        name=None,
6595        password=None,
6596        port=None,
6597        port_override=None,
6598        secret_store_id=None,
6599        tags=None,
6600        username=None,
6601    ):
6602        self.bind_interface = bind_interface if bind_interface is not None else ''
6603        '''
6604         Bind interface
6605        '''
6606        self.database = database if database is not None else ''
6607        self.egress_filter = egress_filter if egress_filter is not None else ''
6608        '''
6609         A filter applied to the routing logic to pin datasource to nodes.
6610        '''
6611        self.healthy = healthy if healthy is not None else False
6612        '''
6613         True if the datasource is reachable and the credentials are valid.
6614        '''
6615        self.hostname = hostname if hostname is not None else ''
6616        self.id = id if id is not None else ''
6617        '''
6618         Unique identifier of the Resource.
6619        '''
6620        self.name = name if name is not None else ''
6621        '''
6622         Unique human-readable name of the Resource.
6623        '''
6624        self.password = password if password is not None else ''
6625        self.port = port if port is not None else 0
6626        self.port_override = port_override if port_override is not None else 0
6627        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6628        '''
6629         ID of the secret store containing credentials for this resource, if any.
6630        '''
6631        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6632        '''
6633         Tags is a map of key, value pairs.
6634        '''
6635        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6654    def to_dict(self):
6655        return {
6656            'bind_interface': self.bind_interface,
6657            'database': self.database,
6658            'egress_filter': self.egress_filter,
6659            'healthy': self.healthy,
6660            'hostname': self.hostname,
6661            'id': self.id,
6662            'name': self.name,
6663            'password': self.password,
6664            'port': self.port,
6665            'port_override': self.port_override,
6666            'secret_store_id': self.secret_store_id,
6667            'tags': self.tags,
6668            'username': self.username,
6669        }
@classmethod
def from_dict(cls, d)
6671    @classmethod
6672    def from_dict(cls, d):
6673        return cls(
6674            bind_interface=d.get('bind_interface'),
6675            database=d.get('database'),
6676            egress_filter=d.get('egress_filter'),
6677            healthy=d.get('healthy'),
6678            hostname=d.get('hostname'),
6679            id=d.get('id'),
6680            name=d.get('name'),
6681            password=d.get('password'),
6682            port=d.get('port'),
6683            port_override=d.get('port_override'),
6684            secret_store_id=d.get('secret_store_id'),
6685            tags=d.get('tags'),
6686            username=d.get('username'),
6687        )
class Memcached:
6690class Memcached:
6691    __slots__ = [
6692        'bind_interface',
6693        'egress_filter',
6694        'healthy',
6695        'hostname',
6696        'id',
6697        'name',
6698        'port',
6699        'port_override',
6700        'secret_store_id',
6701        'tags',
6702    ]
6703
6704    def __init__(
6705        self,
6706        bind_interface=None,
6707        egress_filter=None,
6708        healthy=None,
6709        hostname=None,
6710        id=None,
6711        name=None,
6712        port=None,
6713        port_override=None,
6714        secret_store_id=None,
6715        tags=None,
6716    ):
6717        self.bind_interface = bind_interface if bind_interface is not None else ''
6718        '''
6719         Bind interface
6720        '''
6721        self.egress_filter = egress_filter if egress_filter is not None else ''
6722        '''
6723         A filter applied to the routing logic to pin datasource to nodes.
6724        '''
6725        self.healthy = healthy if healthy is not None else False
6726        '''
6727         True if the datasource is reachable and the credentials are valid.
6728        '''
6729        self.hostname = hostname if hostname is not None else ''
6730        self.id = id if id is not None else ''
6731        '''
6732         Unique identifier of the Resource.
6733        '''
6734        self.name = name if name is not None else ''
6735        '''
6736         Unique human-readable name of the Resource.
6737        '''
6738        self.port = port if port is not None else 0
6739        self.port_override = port_override if port_override is not None else 0
6740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6741        '''
6742         ID of the secret store containing credentials for this resource, if any.
6743        '''
6744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6745        '''
6746         Tags is a map of key, value pairs.
6747        '''
6748
6749    def __repr__(self):
6750        return '<sdm.Memcached ' + \
6751            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6752            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6753            'healthy: ' + repr(self.healthy) + ' ' +\
6754            'hostname: ' + repr(self.hostname) + ' ' +\
6755            'id: ' + repr(self.id) + ' ' +\
6756            'name: ' + repr(self.name) + ' ' +\
6757            'port: ' + repr(self.port) + ' ' +\
6758            'port_override: ' + repr(self.port_override) + ' ' +\
6759            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6760            'tags: ' + repr(self.tags) + ' ' +\
6761            '>'
6762
6763    def to_dict(self):
6764        return {
6765            'bind_interface': self.bind_interface,
6766            'egress_filter': self.egress_filter,
6767            'healthy': self.healthy,
6768            'hostname': self.hostname,
6769            'id': self.id,
6770            'name': self.name,
6771            'port': self.port,
6772            'port_override': self.port_override,
6773            'secret_store_id': self.secret_store_id,
6774            'tags': self.tags,
6775        }
6776
6777    @classmethod
6778    def from_dict(cls, d):
6779        return cls(
6780            bind_interface=d.get('bind_interface'),
6781            egress_filter=d.get('egress_filter'),
6782            healthy=d.get('healthy'),
6783            hostname=d.get('hostname'),
6784            id=d.get('id'),
6785            name=d.get('name'),
6786            port=d.get('port'),
6787            port_override=d.get('port_override'),
6788            secret_store_id=d.get('secret_store_id'),
6789            tags=d.get('tags'),
6790        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6704    def __init__(
6705        self,
6706        bind_interface=None,
6707        egress_filter=None,
6708        healthy=None,
6709        hostname=None,
6710        id=None,
6711        name=None,
6712        port=None,
6713        port_override=None,
6714        secret_store_id=None,
6715        tags=None,
6716    ):
6717        self.bind_interface = bind_interface if bind_interface is not None else ''
6718        '''
6719         Bind interface
6720        '''
6721        self.egress_filter = egress_filter if egress_filter is not None else ''
6722        '''
6723         A filter applied to the routing logic to pin datasource to nodes.
6724        '''
6725        self.healthy = healthy if healthy is not None else False
6726        '''
6727         True if the datasource is reachable and the credentials are valid.
6728        '''
6729        self.hostname = hostname if hostname is not None else ''
6730        self.id = id if id is not None else ''
6731        '''
6732         Unique identifier of the Resource.
6733        '''
6734        self.name = name if name is not None else ''
6735        '''
6736         Unique human-readable name of the Resource.
6737        '''
6738        self.port = port if port is not None else 0
6739        self.port_override = port_override if port_override is not None else 0
6740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6741        '''
6742         ID of the secret store containing credentials for this resource, if any.
6743        '''
6744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6745        '''
6746         Tags is a map of key, value pairs.
6747        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6763    def to_dict(self):
6764        return {
6765            'bind_interface': self.bind_interface,
6766            'egress_filter': self.egress_filter,
6767            'healthy': self.healthy,
6768            'hostname': self.hostname,
6769            'id': self.id,
6770            'name': self.name,
6771            'port': self.port,
6772            'port_override': self.port_override,
6773            'secret_store_id': self.secret_store_id,
6774            'tags': self.tags,
6775        }
@classmethod
def from_dict(cls, d)
6777    @classmethod
6778    def from_dict(cls, d):
6779        return cls(
6780            bind_interface=d.get('bind_interface'),
6781            egress_filter=d.get('egress_filter'),
6782            healthy=d.get('healthy'),
6783            hostname=d.get('hostname'),
6784            id=d.get('id'),
6785            name=d.get('name'),
6786            port=d.get('port'),
6787            port_override=d.get('port_override'),
6788            secret_store_id=d.get('secret_store_id'),
6789            tags=d.get('tags'),
6790        )
class Memsql:
6793class Memsql:
6794    __slots__ = [
6795        'bind_interface',
6796        'database',
6797        'egress_filter',
6798        'healthy',
6799        'hostname',
6800        'id',
6801        'name',
6802        'password',
6803        'port',
6804        'port_override',
6805        'secret_store_id',
6806        'tags',
6807        'username',
6808    ]
6809
6810    def __init__(
6811        self,
6812        bind_interface=None,
6813        database=None,
6814        egress_filter=None,
6815        healthy=None,
6816        hostname=None,
6817        id=None,
6818        name=None,
6819        password=None,
6820        port=None,
6821        port_override=None,
6822        secret_store_id=None,
6823        tags=None,
6824        username=None,
6825    ):
6826        self.bind_interface = bind_interface if bind_interface is not None else ''
6827        '''
6828         Bind interface
6829        '''
6830        self.database = database if database is not None else ''
6831        self.egress_filter = egress_filter if egress_filter is not None else ''
6832        '''
6833         A filter applied to the routing logic to pin datasource to nodes.
6834        '''
6835        self.healthy = healthy if healthy is not None else False
6836        '''
6837         True if the datasource is reachable and the credentials are valid.
6838        '''
6839        self.hostname = hostname if hostname is not None else ''
6840        self.id = id if id is not None else ''
6841        '''
6842         Unique identifier of the Resource.
6843        '''
6844        self.name = name if name is not None else ''
6845        '''
6846         Unique human-readable name of the Resource.
6847        '''
6848        self.password = password if password is not None else ''
6849        self.port = port if port is not None else 0
6850        self.port_override = port_override if port_override is not None else 0
6851        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6852        '''
6853         ID of the secret store containing credentials for this resource, if any.
6854        '''
6855        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6856        '''
6857         Tags is a map of key, value pairs.
6858        '''
6859        self.username = username if username is not None else ''
6860
6861    def __repr__(self):
6862        return '<sdm.Memsql ' + \
6863            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6864            'database: ' + repr(self.database) + ' ' +\
6865            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6866            'healthy: ' + repr(self.healthy) + ' ' +\
6867            'hostname: ' + repr(self.hostname) + ' ' +\
6868            'id: ' + repr(self.id) + ' ' +\
6869            'name: ' + repr(self.name) + ' ' +\
6870            'password: ' + repr(self.password) + ' ' +\
6871            'port: ' + repr(self.port) + ' ' +\
6872            'port_override: ' + repr(self.port_override) + ' ' +\
6873            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6874            'tags: ' + repr(self.tags) + ' ' +\
6875            'username: ' + repr(self.username) + ' ' +\
6876            '>'
6877
6878    def to_dict(self):
6879        return {
6880            'bind_interface': self.bind_interface,
6881            'database': self.database,
6882            'egress_filter': self.egress_filter,
6883            'healthy': self.healthy,
6884            'hostname': self.hostname,
6885            'id': self.id,
6886            'name': self.name,
6887            'password': self.password,
6888            'port': self.port,
6889            'port_override': self.port_override,
6890            'secret_store_id': self.secret_store_id,
6891            'tags': self.tags,
6892            'username': self.username,
6893        }
6894
6895    @classmethod
6896    def from_dict(cls, d):
6897        return cls(
6898            bind_interface=d.get('bind_interface'),
6899            database=d.get('database'),
6900            egress_filter=d.get('egress_filter'),
6901            healthy=d.get('healthy'),
6902            hostname=d.get('hostname'),
6903            id=d.get('id'),
6904            name=d.get('name'),
6905            password=d.get('password'),
6906            port=d.get('port'),
6907            port_override=d.get('port_override'),
6908            secret_store_id=d.get('secret_store_id'),
6909            tags=d.get('tags'),
6910            username=d.get('username'),
6911        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6810    def __init__(
6811        self,
6812        bind_interface=None,
6813        database=None,
6814        egress_filter=None,
6815        healthy=None,
6816        hostname=None,
6817        id=None,
6818        name=None,
6819        password=None,
6820        port=None,
6821        port_override=None,
6822        secret_store_id=None,
6823        tags=None,
6824        username=None,
6825    ):
6826        self.bind_interface = bind_interface if bind_interface is not None else ''
6827        '''
6828         Bind interface
6829        '''
6830        self.database = database if database is not None else ''
6831        self.egress_filter = egress_filter if egress_filter is not None else ''
6832        '''
6833         A filter applied to the routing logic to pin datasource to nodes.
6834        '''
6835        self.healthy = healthy if healthy is not None else False
6836        '''
6837         True if the datasource is reachable and the credentials are valid.
6838        '''
6839        self.hostname = hostname if hostname is not None else ''
6840        self.id = id if id is not None else ''
6841        '''
6842         Unique identifier of the Resource.
6843        '''
6844        self.name = name if name is not None else ''
6845        '''
6846         Unique human-readable name of the Resource.
6847        '''
6848        self.password = password if password is not None else ''
6849        self.port = port if port is not None else 0
6850        self.port_override = port_override if port_override is not None else 0
6851        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6852        '''
6853         ID of the secret store containing credentials for this resource, if any.
6854        '''
6855        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6856        '''
6857         Tags is a map of key, value pairs.
6858        '''
6859        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6878    def to_dict(self):
6879        return {
6880            'bind_interface': self.bind_interface,
6881            'database': self.database,
6882            'egress_filter': self.egress_filter,
6883            'healthy': self.healthy,
6884            'hostname': self.hostname,
6885            'id': self.id,
6886            'name': self.name,
6887            'password': self.password,
6888            'port': self.port,
6889            'port_override': self.port_override,
6890            'secret_store_id': self.secret_store_id,
6891            'tags': self.tags,
6892            'username': self.username,
6893        }
@classmethod
def from_dict(cls, d)
6895    @classmethod
6896    def from_dict(cls, d):
6897        return cls(
6898            bind_interface=d.get('bind_interface'),
6899            database=d.get('database'),
6900            egress_filter=d.get('egress_filter'),
6901            healthy=d.get('healthy'),
6902            hostname=d.get('hostname'),
6903            id=d.get('id'),
6904            name=d.get('name'),
6905            password=d.get('password'),
6906            port=d.get('port'),
6907            port_override=d.get('port_override'),
6908            secret_store_id=d.get('secret_store_id'),
6909            tags=d.get('tags'),
6910            username=d.get('username'),
6911        )
class MongoHost:
6914class MongoHost:
6915    '''
6916    MongoHost is currently unstable, and its API may change, or it may be removed,
6917    without a major version bump.
6918    '''
6919    __slots__ = [
6920        'auth_database',
6921        'bind_interface',
6922        'egress_filter',
6923        'healthy',
6924        'hostname',
6925        'id',
6926        'name',
6927        'password',
6928        'port',
6929        'port_override',
6930        'secret_store_id',
6931        'tags',
6932        'tls_required',
6933        'username',
6934    ]
6935
6936    def __init__(
6937        self,
6938        auth_database=None,
6939        bind_interface=None,
6940        egress_filter=None,
6941        healthy=None,
6942        hostname=None,
6943        id=None,
6944        name=None,
6945        password=None,
6946        port=None,
6947        port_override=None,
6948        secret_store_id=None,
6949        tags=None,
6950        tls_required=None,
6951        username=None,
6952    ):
6953        self.auth_database = auth_database if auth_database is not None else ''
6954        self.bind_interface = bind_interface if bind_interface is not None else ''
6955        '''
6956         Bind interface
6957        '''
6958        self.egress_filter = egress_filter if egress_filter is not None else ''
6959        '''
6960         A filter applied to the routing logic to pin datasource to nodes.
6961        '''
6962        self.healthy = healthy if healthy is not None else False
6963        '''
6964         True if the datasource is reachable and the credentials are valid.
6965        '''
6966        self.hostname = hostname if hostname is not None else ''
6967        self.id = id if id is not None else ''
6968        '''
6969         Unique identifier of the Resource.
6970        '''
6971        self.name = name if name is not None else ''
6972        '''
6973         Unique human-readable name of the Resource.
6974        '''
6975        self.password = password if password is not None else ''
6976        self.port = port if port is not None else 0
6977        self.port_override = port_override if port_override is not None else 0
6978        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6979        '''
6980         ID of the secret store containing credentials for this resource, if any.
6981        '''
6982        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6983        '''
6984         Tags is a map of key, value pairs.
6985        '''
6986        self.tls_required = tls_required if tls_required is not None else False
6987        self.username = username if username is not None else ''
6988
6989    def __repr__(self):
6990        return '<sdm.MongoHost ' + \
6991            'auth_database: ' + repr(self.auth_database) + ' ' +\
6992            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6993            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6994            'healthy: ' + repr(self.healthy) + ' ' +\
6995            'hostname: ' + repr(self.hostname) + ' ' +\
6996            'id: ' + repr(self.id) + ' ' +\
6997            'name: ' + repr(self.name) + ' ' +\
6998            'password: ' + repr(self.password) + ' ' +\
6999            'port: ' + repr(self.port) + ' ' +\
7000            'port_override: ' + repr(self.port_override) + ' ' +\
7001            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7002            'tags: ' + repr(self.tags) + ' ' +\
7003            'tls_required: ' + repr(self.tls_required) + ' ' +\
7004            'username: ' + repr(self.username) + ' ' +\
7005            '>'
7006
7007    def to_dict(self):
7008        return {
7009            'auth_database': self.auth_database,
7010            'bind_interface': self.bind_interface,
7011            'egress_filter': self.egress_filter,
7012            'healthy': self.healthy,
7013            'hostname': self.hostname,
7014            'id': self.id,
7015            'name': self.name,
7016            'password': self.password,
7017            'port': self.port,
7018            'port_override': self.port_override,
7019            'secret_store_id': self.secret_store_id,
7020            'tags': self.tags,
7021            'tls_required': self.tls_required,
7022            'username': self.username,
7023        }
7024
7025    @classmethod
7026    def from_dict(cls, d):
7027        return cls(
7028            auth_database=d.get('auth_database'),
7029            bind_interface=d.get('bind_interface'),
7030            egress_filter=d.get('egress_filter'),
7031            healthy=d.get('healthy'),
7032            hostname=d.get('hostname'),
7033            id=d.get('id'),
7034            name=d.get('name'),
7035            password=d.get('password'),
7036            port=d.get('port'),
7037            port_override=d.get('port_override'),
7038            secret_store_id=d.get('secret_store_id'),
7039            tags=d.get('tags'),
7040            tls_required=d.get('tls_required'),
7041            username=d.get('username'),
7042        )

MongoHost is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
6936    def __init__(
6937        self,
6938        auth_database=None,
6939        bind_interface=None,
6940        egress_filter=None,
6941        healthy=None,
6942        hostname=None,
6943        id=None,
6944        name=None,
6945        password=None,
6946        port=None,
6947        port_override=None,
6948        secret_store_id=None,
6949        tags=None,
6950        tls_required=None,
6951        username=None,
6952    ):
6953        self.auth_database = auth_database if auth_database is not None else ''
6954        self.bind_interface = bind_interface if bind_interface is not None else ''
6955        '''
6956         Bind interface
6957        '''
6958        self.egress_filter = egress_filter if egress_filter is not None else ''
6959        '''
6960         A filter applied to the routing logic to pin datasource to nodes.
6961        '''
6962        self.healthy = healthy if healthy is not None else False
6963        '''
6964         True if the datasource is reachable and the credentials are valid.
6965        '''
6966        self.hostname = hostname if hostname is not None else ''
6967        self.id = id if id is not None else ''
6968        '''
6969         Unique identifier of the Resource.
6970        '''
6971        self.name = name if name is not None else ''
6972        '''
6973         Unique human-readable name of the Resource.
6974        '''
6975        self.password = password if password is not None else ''
6976        self.port = port if port is not None else 0
6977        self.port_override = port_override if port_override is not None else 0
6978        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6979        '''
6980         ID of the secret store containing credentials for this resource, if any.
6981        '''
6982        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6983        '''
6984         Tags is a map of key, value pairs.
6985        '''
6986        self.tls_required = tls_required if tls_required is not None else False
6987        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7007    def to_dict(self):
7008        return {
7009            'auth_database': self.auth_database,
7010            'bind_interface': self.bind_interface,
7011            'egress_filter': self.egress_filter,
7012            'healthy': self.healthy,
7013            'hostname': self.hostname,
7014            'id': self.id,
7015            'name': self.name,
7016            'password': self.password,
7017            'port': self.port,
7018            'port_override': self.port_override,
7019            'secret_store_id': self.secret_store_id,
7020            'tags': self.tags,
7021            'tls_required': self.tls_required,
7022            'username': self.username,
7023        }
@classmethod
def from_dict(cls, d)
7025    @classmethod
7026    def from_dict(cls, d):
7027        return cls(
7028            auth_database=d.get('auth_database'),
7029            bind_interface=d.get('bind_interface'),
7030            egress_filter=d.get('egress_filter'),
7031            healthy=d.get('healthy'),
7032            hostname=d.get('hostname'),
7033            id=d.get('id'),
7034            name=d.get('name'),
7035            password=d.get('password'),
7036            port=d.get('port'),
7037            port_override=d.get('port_override'),
7038            secret_store_id=d.get('secret_store_id'),
7039            tags=d.get('tags'),
7040            tls_required=d.get('tls_required'),
7041            username=d.get('username'),
7042        )
class MongoLegacyHost:
7045class MongoLegacyHost:
7046    __slots__ = [
7047        'auth_database',
7048        'bind_interface',
7049        'egress_filter',
7050        'healthy',
7051        'hostname',
7052        'id',
7053        'name',
7054        'password',
7055        'port',
7056        'port_override',
7057        'replica_set',
7058        'secret_store_id',
7059        'tags',
7060        'tls_required',
7061        'username',
7062    ]
7063
7064    def __init__(
7065        self,
7066        auth_database=None,
7067        bind_interface=None,
7068        egress_filter=None,
7069        healthy=None,
7070        hostname=None,
7071        id=None,
7072        name=None,
7073        password=None,
7074        port=None,
7075        port_override=None,
7076        replica_set=None,
7077        secret_store_id=None,
7078        tags=None,
7079        tls_required=None,
7080        username=None,
7081    ):
7082        self.auth_database = auth_database if auth_database is not None else ''
7083        self.bind_interface = bind_interface if bind_interface is not None else ''
7084        '''
7085         Bind interface
7086        '''
7087        self.egress_filter = egress_filter if egress_filter is not None else ''
7088        '''
7089         A filter applied to the routing logic to pin datasource to nodes.
7090        '''
7091        self.healthy = healthy if healthy is not None else False
7092        '''
7093         True if the datasource is reachable and the credentials are valid.
7094        '''
7095        self.hostname = hostname if hostname is not None else ''
7096        self.id = id if id is not None else ''
7097        '''
7098         Unique identifier of the Resource.
7099        '''
7100        self.name = name if name is not None else ''
7101        '''
7102         Unique human-readable name of the Resource.
7103        '''
7104        self.password = password if password is not None else ''
7105        self.port = port if port is not None else 0
7106        self.port_override = port_override if port_override is not None else 0
7107        self.replica_set = replica_set if replica_set is not None else ''
7108        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7109        '''
7110         ID of the secret store containing credentials for this resource, if any.
7111        '''
7112        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7113        '''
7114         Tags is a map of key, value pairs.
7115        '''
7116        self.tls_required = tls_required if tls_required is not None else False
7117        self.username = username if username is not None else ''
7118
7119    def __repr__(self):
7120        return '<sdm.MongoLegacyHost ' + \
7121            'auth_database: ' + repr(self.auth_database) + ' ' +\
7122            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7123            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7124            'healthy: ' + repr(self.healthy) + ' ' +\
7125            'hostname: ' + repr(self.hostname) + ' ' +\
7126            'id: ' + repr(self.id) + ' ' +\
7127            'name: ' + repr(self.name) + ' ' +\
7128            'password: ' + repr(self.password) + ' ' +\
7129            'port: ' + repr(self.port) + ' ' +\
7130            'port_override: ' + repr(self.port_override) + ' ' +\
7131            'replica_set: ' + repr(self.replica_set) + ' ' +\
7132            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7133            'tags: ' + repr(self.tags) + ' ' +\
7134            'tls_required: ' + repr(self.tls_required) + ' ' +\
7135            'username: ' + repr(self.username) + ' ' +\
7136            '>'
7137
7138    def to_dict(self):
7139        return {
7140            'auth_database': self.auth_database,
7141            'bind_interface': self.bind_interface,
7142            'egress_filter': self.egress_filter,
7143            'healthy': self.healthy,
7144            'hostname': self.hostname,
7145            'id': self.id,
7146            'name': self.name,
7147            'password': self.password,
7148            'port': self.port,
7149            'port_override': self.port_override,
7150            'replica_set': self.replica_set,
7151            'secret_store_id': self.secret_store_id,
7152            'tags': self.tags,
7153            'tls_required': self.tls_required,
7154            'username': self.username,
7155        }
7156
7157    @classmethod
7158    def from_dict(cls, d):
7159        return cls(
7160            auth_database=d.get('auth_database'),
7161            bind_interface=d.get('bind_interface'),
7162            egress_filter=d.get('egress_filter'),
7163            healthy=d.get('healthy'),
7164            hostname=d.get('hostname'),
7165            id=d.get('id'),
7166            name=d.get('name'),
7167            password=d.get('password'),
7168            port=d.get('port'),
7169            port_override=d.get('port_override'),
7170            replica_set=d.get('replica_set'),
7171            secret_store_id=d.get('secret_store_id'),
7172            tags=d.get('tags'),
7173            tls_required=d.get('tls_required'),
7174            username=d.get('username'),
7175        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7064    def __init__(
7065        self,
7066        auth_database=None,
7067        bind_interface=None,
7068        egress_filter=None,
7069        healthy=None,
7070        hostname=None,
7071        id=None,
7072        name=None,
7073        password=None,
7074        port=None,
7075        port_override=None,
7076        replica_set=None,
7077        secret_store_id=None,
7078        tags=None,
7079        tls_required=None,
7080        username=None,
7081    ):
7082        self.auth_database = auth_database if auth_database is not None else ''
7083        self.bind_interface = bind_interface if bind_interface is not None else ''
7084        '''
7085         Bind interface
7086        '''
7087        self.egress_filter = egress_filter if egress_filter is not None else ''
7088        '''
7089         A filter applied to the routing logic to pin datasource to nodes.
7090        '''
7091        self.healthy = healthy if healthy is not None else False
7092        '''
7093         True if the datasource is reachable and the credentials are valid.
7094        '''
7095        self.hostname = hostname if hostname is not None else ''
7096        self.id = id if id is not None else ''
7097        '''
7098         Unique identifier of the Resource.
7099        '''
7100        self.name = name if name is not None else ''
7101        '''
7102         Unique human-readable name of the Resource.
7103        '''
7104        self.password = password if password is not None else ''
7105        self.port = port if port is not None else 0
7106        self.port_override = port_override if port_override is not None else 0
7107        self.replica_set = replica_set if replica_set is not None else ''
7108        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7109        '''
7110         ID of the secret store containing credentials for this resource, if any.
7111        '''
7112        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7113        '''
7114         Tags is a map of key, value pairs.
7115        '''
7116        self.tls_required = tls_required if tls_required is not None else False
7117        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7138    def to_dict(self):
7139        return {
7140            'auth_database': self.auth_database,
7141            'bind_interface': self.bind_interface,
7142            'egress_filter': self.egress_filter,
7143            'healthy': self.healthy,
7144            'hostname': self.hostname,
7145            'id': self.id,
7146            'name': self.name,
7147            'password': self.password,
7148            'port': self.port,
7149            'port_override': self.port_override,
7150            'replica_set': self.replica_set,
7151            'secret_store_id': self.secret_store_id,
7152            'tags': self.tags,
7153            'tls_required': self.tls_required,
7154            'username': self.username,
7155        }
@classmethod
def from_dict(cls, d)
7157    @classmethod
7158    def from_dict(cls, d):
7159        return cls(
7160            auth_database=d.get('auth_database'),
7161            bind_interface=d.get('bind_interface'),
7162            egress_filter=d.get('egress_filter'),
7163            healthy=d.get('healthy'),
7164            hostname=d.get('hostname'),
7165            id=d.get('id'),
7166            name=d.get('name'),
7167            password=d.get('password'),
7168            port=d.get('port'),
7169            port_override=d.get('port_override'),
7170            replica_set=d.get('replica_set'),
7171            secret_store_id=d.get('secret_store_id'),
7172            tags=d.get('tags'),
7173            tls_required=d.get('tls_required'),
7174            username=d.get('username'),
7175        )
class MongoLegacyReplicaset:
7178class MongoLegacyReplicaset:
7179    __slots__ = [
7180        'auth_database',
7181        'bind_interface',
7182        'connect_to_replica',
7183        'egress_filter',
7184        'healthy',
7185        'hostname',
7186        'id',
7187        'name',
7188        'password',
7189        'port',
7190        'port_override',
7191        'replica_set',
7192        'secret_store_id',
7193        'tags',
7194        'tls_required',
7195        'username',
7196    ]
7197
7198    def __init__(
7199        self,
7200        auth_database=None,
7201        bind_interface=None,
7202        connect_to_replica=None,
7203        egress_filter=None,
7204        healthy=None,
7205        hostname=None,
7206        id=None,
7207        name=None,
7208        password=None,
7209        port=None,
7210        port_override=None,
7211        replica_set=None,
7212        secret_store_id=None,
7213        tags=None,
7214        tls_required=None,
7215        username=None,
7216    ):
7217        self.auth_database = auth_database if auth_database is not None else ''
7218        self.bind_interface = bind_interface if bind_interface is not None else ''
7219        '''
7220         Bind interface
7221        '''
7222        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7223        self.egress_filter = egress_filter if egress_filter is not None else ''
7224        '''
7225         A filter applied to the routing logic to pin datasource to nodes.
7226        '''
7227        self.healthy = healthy if healthy is not None else False
7228        '''
7229         True if the datasource is reachable and the credentials are valid.
7230        '''
7231        self.hostname = hostname if hostname is not None else ''
7232        self.id = id if id is not None else ''
7233        '''
7234         Unique identifier of the Resource.
7235        '''
7236        self.name = name if name is not None else ''
7237        '''
7238         Unique human-readable name of the Resource.
7239        '''
7240        self.password = password if password is not None else ''
7241        self.port = port if port is not None else 0
7242        self.port_override = port_override if port_override is not None else 0
7243        self.replica_set = replica_set if replica_set is not None else ''
7244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7245        '''
7246         ID of the secret store containing credentials for this resource, if any.
7247        '''
7248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7249        '''
7250         Tags is a map of key, value pairs.
7251        '''
7252        self.tls_required = tls_required if tls_required is not None else False
7253        self.username = username if username is not None else ''
7254
7255    def __repr__(self):
7256        return '<sdm.MongoLegacyReplicaset ' + \
7257            'auth_database: ' + repr(self.auth_database) + ' ' +\
7258            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7259            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7260            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7261            'healthy: ' + repr(self.healthy) + ' ' +\
7262            'hostname: ' + repr(self.hostname) + ' ' +\
7263            'id: ' + repr(self.id) + ' ' +\
7264            'name: ' + repr(self.name) + ' ' +\
7265            'password: ' + repr(self.password) + ' ' +\
7266            'port: ' + repr(self.port) + ' ' +\
7267            'port_override: ' + repr(self.port_override) + ' ' +\
7268            'replica_set: ' + repr(self.replica_set) + ' ' +\
7269            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7270            'tags: ' + repr(self.tags) + ' ' +\
7271            'tls_required: ' + repr(self.tls_required) + ' ' +\
7272            'username: ' + repr(self.username) + ' ' +\
7273            '>'
7274
7275    def to_dict(self):
7276        return {
7277            'auth_database': self.auth_database,
7278            'bind_interface': self.bind_interface,
7279            'connect_to_replica': self.connect_to_replica,
7280            'egress_filter': self.egress_filter,
7281            'healthy': self.healthy,
7282            'hostname': self.hostname,
7283            'id': self.id,
7284            'name': self.name,
7285            'password': self.password,
7286            'port': self.port,
7287            'port_override': self.port_override,
7288            'replica_set': self.replica_set,
7289            'secret_store_id': self.secret_store_id,
7290            'tags': self.tags,
7291            'tls_required': self.tls_required,
7292            'username': self.username,
7293        }
7294
7295    @classmethod
7296    def from_dict(cls, d):
7297        return cls(
7298            auth_database=d.get('auth_database'),
7299            bind_interface=d.get('bind_interface'),
7300            connect_to_replica=d.get('connect_to_replica'),
7301            egress_filter=d.get('egress_filter'),
7302            healthy=d.get('healthy'),
7303            hostname=d.get('hostname'),
7304            id=d.get('id'),
7305            name=d.get('name'),
7306            password=d.get('password'),
7307            port=d.get('port'),
7308            port_override=d.get('port_override'),
7309            replica_set=d.get('replica_set'),
7310            secret_store_id=d.get('secret_store_id'),
7311            tags=d.get('tags'),
7312            tls_required=d.get('tls_required'),
7313            username=d.get('username'),
7314        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7198    def __init__(
7199        self,
7200        auth_database=None,
7201        bind_interface=None,
7202        connect_to_replica=None,
7203        egress_filter=None,
7204        healthy=None,
7205        hostname=None,
7206        id=None,
7207        name=None,
7208        password=None,
7209        port=None,
7210        port_override=None,
7211        replica_set=None,
7212        secret_store_id=None,
7213        tags=None,
7214        tls_required=None,
7215        username=None,
7216    ):
7217        self.auth_database = auth_database if auth_database is not None else ''
7218        self.bind_interface = bind_interface if bind_interface is not None else ''
7219        '''
7220         Bind interface
7221        '''
7222        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7223        self.egress_filter = egress_filter if egress_filter is not None else ''
7224        '''
7225         A filter applied to the routing logic to pin datasource to nodes.
7226        '''
7227        self.healthy = healthy if healthy is not None else False
7228        '''
7229         True if the datasource is reachable and the credentials are valid.
7230        '''
7231        self.hostname = hostname if hostname is not None else ''
7232        self.id = id if id is not None else ''
7233        '''
7234         Unique identifier of the Resource.
7235        '''
7236        self.name = name if name is not None else ''
7237        '''
7238         Unique human-readable name of the Resource.
7239        '''
7240        self.password = password if password is not None else ''
7241        self.port = port if port is not None else 0
7242        self.port_override = port_override if port_override is not None else 0
7243        self.replica_set = replica_set if replica_set is not None else ''
7244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7245        '''
7246         ID of the secret store containing credentials for this resource, if any.
7247        '''
7248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7249        '''
7250         Tags is a map of key, value pairs.
7251        '''
7252        self.tls_required = tls_required if tls_required is not None else False
7253        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7275    def to_dict(self):
7276        return {
7277            'auth_database': self.auth_database,
7278            'bind_interface': self.bind_interface,
7279            'connect_to_replica': self.connect_to_replica,
7280            'egress_filter': self.egress_filter,
7281            'healthy': self.healthy,
7282            'hostname': self.hostname,
7283            'id': self.id,
7284            'name': self.name,
7285            'password': self.password,
7286            'port': self.port,
7287            'port_override': self.port_override,
7288            'replica_set': self.replica_set,
7289            'secret_store_id': self.secret_store_id,
7290            'tags': self.tags,
7291            'tls_required': self.tls_required,
7292            'username': self.username,
7293        }
@classmethod
def from_dict(cls, d)
7295    @classmethod
7296    def from_dict(cls, d):
7297        return cls(
7298            auth_database=d.get('auth_database'),
7299            bind_interface=d.get('bind_interface'),
7300            connect_to_replica=d.get('connect_to_replica'),
7301            egress_filter=d.get('egress_filter'),
7302            healthy=d.get('healthy'),
7303            hostname=d.get('hostname'),
7304            id=d.get('id'),
7305            name=d.get('name'),
7306            password=d.get('password'),
7307            port=d.get('port'),
7308            port_override=d.get('port_override'),
7309            replica_set=d.get('replica_set'),
7310            secret_store_id=d.get('secret_store_id'),
7311            tags=d.get('tags'),
7312            tls_required=d.get('tls_required'),
7313            username=d.get('username'),
7314        )
class MongoReplicaSet:
7317class MongoReplicaSet:
7318    '''
7319    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
7320    without a major version bump.
7321    '''
7322    __slots__ = [
7323        'auth_database',
7324        'bind_interface',
7325        'connect_to_replica',
7326        'egress_filter',
7327        'healthy',
7328        'hostname',
7329        'id',
7330        'name',
7331        'password',
7332        'port',
7333        'port_override',
7334        'replica_set',
7335        'secret_store_id',
7336        'tags',
7337        'tls_required',
7338        'username',
7339    ]
7340
7341    def __init__(
7342        self,
7343        auth_database=None,
7344        bind_interface=None,
7345        connect_to_replica=None,
7346        egress_filter=None,
7347        healthy=None,
7348        hostname=None,
7349        id=None,
7350        name=None,
7351        password=None,
7352        port=None,
7353        port_override=None,
7354        replica_set=None,
7355        secret_store_id=None,
7356        tags=None,
7357        tls_required=None,
7358        username=None,
7359    ):
7360        self.auth_database = auth_database if auth_database is not None else ''
7361        self.bind_interface = bind_interface if bind_interface is not None else ''
7362        '''
7363         Bind interface
7364        '''
7365        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7366        self.egress_filter = egress_filter if egress_filter is not None else ''
7367        '''
7368         A filter applied to the routing logic to pin datasource to nodes.
7369        '''
7370        self.healthy = healthy if healthy is not None else False
7371        '''
7372         True if the datasource is reachable and the credentials are valid.
7373        '''
7374        self.hostname = hostname if hostname is not None else ''
7375        self.id = id if id is not None else ''
7376        '''
7377         Unique identifier of the Resource.
7378        '''
7379        self.name = name if name is not None else ''
7380        '''
7381         Unique human-readable name of the Resource.
7382        '''
7383        self.password = password if password is not None else ''
7384        self.port = port if port is not None else 0
7385        self.port_override = port_override if port_override is not None else 0
7386        self.replica_set = replica_set if replica_set is not None else ''
7387        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7388        '''
7389         ID of the secret store containing credentials for this resource, if any.
7390        '''
7391        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7392        '''
7393         Tags is a map of key, value pairs.
7394        '''
7395        self.tls_required = tls_required if tls_required is not None else False
7396        self.username = username if username is not None else ''
7397
7398    def __repr__(self):
7399        return '<sdm.MongoReplicaSet ' + \
7400            'auth_database: ' + repr(self.auth_database) + ' ' +\
7401            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7402            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7403            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7404            'healthy: ' + repr(self.healthy) + ' ' +\
7405            'hostname: ' + repr(self.hostname) + ' ' +\
7406            'id: ' + repr(self.id) + ' ' +\
7407            'name: ' + repr(self.name) + ' ' +\
7408            'password: ' + repr(self.password) + ' ' +\
7409            'port: ' + repr(self.port) + ' ' +\
7410            'port_override: ' + repr(self.port_override) + ' ' +\
7411            'replica_set: ' + repr(self.replica_set) + ' ' +\
7412            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7413            'tags: ' + repr(self.tags) + ' ' +\
7414            'tls_required: ' + repr(self.tls_required) + ' ' +\
7415            'username: ' + repr(self.username) + ' ' +\
7416            '>'
7417
7418    def to_dict(self):
7419        return {
7420            'auth_database': self.auth_database,
7421            'bind_interface': self.bind_interface,
7422            'connect_to_replica': self.connect_to_replica,
7423            'egress_filter': self.egress_filter,
7424            'healthy': self.healthy,
7425            'hostname': self.hostname,
7426            'id': self.id,
7427            'name': self.name,
7428            'password': self.password,
7429            'port': self.port,
7430            'port_override': self.port_override,
7431            'replica_set': self.replica_set,
7432            'secret_store_id': self.secret_store_id,
7433            'tags': self.tags,
7434            'tls_required': self.tls_required,
7435            'username': self.username,
7436        }
7437
7438    @classmethod
7439    def from_dict(cls, d):
7440        return cls(
7441            auth_database=d.get('auth_database'),
7442            bind_interface=d.get('bind_interface'),
7443            connect_to_replica=d.get('connect_to_replica'),
7444            egress_filter=d.get('egress_filter'),
7445            healthy=d.get('healthy'),
7446            hostname=d.get('hostname'),
7447            id=d.get('id'),
7448            name=d.get('name'),
7449            password=d.get('password'),
7450            port=d.get('port'),
7451            port_override=d.get('port_override'),
7452            replica_set=d.get('replica_set'),
7453            secret_store_id=d.get('secret_store_id'),
7454            tags=d.get('tags'),
7455            tls_required=d.get('tls_required'),
7456            username=d.get('username'),
7457        )

MongoReplicaSet is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7341    def __init__(
7342        self,
7343        auth_database=None,
7344        bind_interface=None,
7345        connect_to_replica=None,
7346        egress_filter=None,
7347        healthy=None,
7348        hostname=None,
7349        id=None,
7350        name=None,
7351        password=None,
7352        port=None,
7353        port_override=None,
7354        replica_set=None,
7355        secret_store_id=None,
7356        tags=None,
7357        tls_required=None,
7358        username=None,
7359    ):
7360        self.auth_database = auth_database if auth_database is not None else ''
7361        self.bind_interface = bind_interface if bind_interface is not None else ''
7362        '''
7363         Bind interface
7364        '''
7365        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7366        self.egress_filter = egress_filter if egress_filter is not None else ''
7367        '''
7368         A filter applied to the routing logic to pin datasource to nodes.
7369        '''
7370        self.healthy = healthy if healthy is not None else False
7371        '''
7372         True if the datasource is reachable and the credentials are valid.
7373        '''
7374        self.hostname = hostname if hostname is not None else ''
7375        self.id = id if id is not None else ''
7376        '''
7377         Unique identifier of the Resource.
7378        '''
7379        self.name = name if name is not None else ''
7380        '''
7381         Unique human-readable name of the Resource.
7382        '''
7383        self.password = password if password is not None else ''
7384        self.port = port if port is not None else 0
7385        self.port_override = port_override if port_override is not None else 0
7386        self.replica_set = replica_set if replica_set is not None else ''
7387        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7388        '''
7389         ID of the secret store containing credentials for this resource, if any.
7390        '''
7391        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7392        '''
7393         Tags is a map of key, value pairs.
7394        '''
7395        self.tls_required = tls_required if tls_required is not None else False
7396        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7418    def to_dict(self):
7419        return {
7420            'auth_database': self.auth_database,
7421            'bind_interface': self.bind_interface,
7422            'connect_to_replica': self.connect_to_replica,
7423            'egress_filter': self.egress_filter,
7424            'healthy': self.healthy,
7425            'hostname': self.hostname,
7426            'id': self.id,
7427            'name': self.name,
7428            'password': self.password,
7429            'port': self.port,
7430            'port_override': self.port_override,
7431            'replica_set': self.replica_set,
7432            'secret_store_id': self.secret_store_id,
7433            'tags': self.tags,
7434            'tls_required': self.tls_required,
7435            'username': self.username,
7436        }
@classmethod
def from_dict(cls, d)
7438    @classmethod
7439    def from_dict(cls, d):
7440        return cls(
7441            auth_database=d.get('auth_database'),
7442            bind_interface=d.get('bind_interface'),
7443            connect_to_replica=d.get('connect_to_replica'),
7444            egress_filter=d.get('egress_filter'),
7445            healthy=d.get('healthy'),
7446            hostname=d.get('hostname'),
7447            id=d.get('id'),
7448            name=d.get('name'),
7449            password=d.get('password'),
7450            port=d.get('port'),
7451            port_override=d.get('port_override'),
7452            replica_set=d.get('replica_set'),
7453            secret_store_id=d.get('secret_store_id'),
7454            tags=d.get('tags'),
7455            tls_required=d.get('tls_required'),
7456            username=d.get('username'),
7457        )
class MongoShardedCluster:
7460class MongoShardedCluster:
7461    '''
7462    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
7463    without a major version bump.
7464    '''
7465    __slots__ = [
7466        'auth_database',
7467        'bind_interface',
7468        'egress_filter',
7469        'healthy',
7470        'hostname',
7471        'id',
7472        'name',
7473        'password',
7474        'port_override',
7475        'secret_store_id',
7476        'tags',
7477        'tls_required',
7478        'username',
7479    ]
7480
7481    def __init__(
7482        self,
7483        auth_database=None,
7484        bind_interface=None,
7485        egress_filter=None,
7486        healthy=None,
7487        hostname=None,
7488        id=None,
7489        name=None,
7490        password=None,
7491        port_override=None,
7492        secret_store_id=None,
7493        tags=None,
7494        tls_required=None,
7495        username=None,
7496    ):
7497        self.auth_database = auth_database if auth_database is not None else ''
7498        self.bind_interface = bind_interface if bind_interface is not None else ''
7499        '''
7500         Bind interface
7501        '''
7502        self.egress_filter = egress_filter if egress_filter is not None else ''
7503        '''
7504         A filter applied to the routing logic to pin datasource to nodes.
7505        '''
7506        self.healthy = healthy if healthy is not None else False
7507        '''
7508         True if the datasource is reachable and the credentials are valid.
7509        '''
7510        self.hostname = hostname if hostname is not None else ''
7511        self.id = id if id is not None else ''
7512        '''
7513         Unique identifier of the Resource.
7514        '''
7515        self.name = name if name is not None else ''
7516        '''
7517         Unique human-readable name of the Resource.
7518        '''
7519        self.password = password if password is not None else ''
7520        self.port_override = port_override if port_override is not None else 0
7521        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7522        '''
7523         ID of the secret store containing credentials for this resource, if any.
7524        '''
7525        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7526        '''
7527         Tags is a map of key, value pairs.
7528        '''
7529        self.tls_required = tls_required if tls_required is not None else False
7530        self.username = username if username is not None else ''
7531
7532    def __repr__(self):
7533        return '<sdm.MongoShardedCluster ' + \
7534            'auth_database: ' + repr(self.auth_database) + ' ' +\
7535            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7536            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7537            'healthy: ' + repr(self.healthy) + ' ' +\
7538            'hostname: ' + repr(self.hostname) + ' ' +\
7539            'id: ' + repr(self.id) + ' ' +\
7540            'name: ' + repr(self.name) + ' ' +\
7541            'password: ' + repr(self.password) + ' ' +\
7542            'port_override: ' + repr(self.port_override) + ' ' +\
7543            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7544            'tags: ' + repr(self.tags) + ' ' +\
7545            'tls_required: ' + repr(self.tls_required) + ' ' +\
7546            'username: ' + repr(self.username) + ' ' +\
7547            '>'
7548
7549    def to_dict(self):
7550        return {
7551            'auth_database': self.auth_database,
7552            'bind_interface': self.bind_interface,
7553            'egress_filter': self.egress_filter,
7554            'healthy': self.healthy,
7555            'hostname': self.hostname,
7556            'id': self.id,
7557            'name': self.name,
7558            'password': self.password,
7559            'port_override': self.port_override,
7560            'secret_store_id': self.secret_store_id,
7561            'tags': self.tags,
7562            'tls_required': self.tls_required,
7563            'username': self.username,
7564        }
7565
7566    @classmethod
7567    def from_dict(cls, d):
7568        return cls(
7569            auth_database=d.get('auth_database'),
7570            bind_interface=d.get('bind_interface'),
7571            egress_filter=d.get('egress_filter'),
7572            healthy=d.get('healthy'),
7573            hostname=d.get('hostname'),
7574            id=d.get('id'),
7575            name=d.get('name'),
7576            password=d.get('password'),
7577            port_override=d.get('port_override'),
7578            secret_store_id=d.get('secret_store_id'),
7579            tags=d.get('tags'),
7580            tls_required=d.get('tls_required'),
7581            username=d.get('username'),
7582        )

MongoShardedCluster is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7481    def __init__(
7482        self,
7483        auth_database=None,
7484        bind_interface=None,
7485        egress_filter=None,
7486        healthy=None,
7487        hostname=None,
7488        id=None,
7489        name=None,
7490        password=None,
7491        port_override=None,
7492        secret_store_id=None,
7493        tags=None,
7494        tls_required=None,
7495        username=None,
7496    ):
7497        self.auth_database = auth_database if auth_database is not None else ''
7498        self.bind_interface = bind_interface if bind_interface is not None else ''
7499        '''
7500         Bind interface
7501        '''
7502        self.egress_filter = egress_filter if egress_filter is not None else ''
7503        '''
7504         A filter applied to the routing logic to pin datasource to nodes.
7505        '''
7506        self.healthy = healthy if healthy is not None else False
7507        '''
7508         True if the datasource is reachable and the credentials are valid.
7509        '''
7510        self.hostname = hostname if hostname is not None else ''
7511        self.id = id if id is not None else ''
7512        '''
7513         Unique identifier of the Resource.
7514        '''
7515        self.name = name if name is not None else ''
7516        '''
7517         Unique human-readable name of the Resource.
7518        '''
7519        self.password = password if password is not None else ''
7520        self.port_override = port_override if port_override is not None else 0
7521        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7522        '''
7523         ID of the secret store containing credentials for this resource, if any.
7524        '''
7525        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7526        '''
7527         Tags is a map of key, value pairs.
7528        '''
7529        self.tls_required = tls_required if tls_required is not None else False
7530        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7549    def to_dict(self):
7550        return {
7551            'auth_database': self.auth_database,
7552            'bind_interface': self.bind_interface,
7553            'egress_filter': self.egress_filter,
7554            'healthy': self.healthy,
7555            'hostname': self.hostname,
7556            'id': self.id,
7557            'name': self.name,
7558            'password': self.password,
7559            'port_override': self.port_override,
7560            'secret_store_id': self.secret_store_id,
7561            'tags': self.tags,
7562            'tls_required': self.tls_required,
7563            'username': self.username,
7564        }
@classmethod
def from_dict(cls, d)
7566    @classmethod
7567    def from_dict(cls, d):
7568        return cls(
7569            auth_database=d.get('auth_database'),
7570            bind_interface=d.get('bind_interface'),
7571            egress_filter=d.get('egress_filter'),
7572            healthy=d.get('healthy'),
7573            hostname=d.get('hostname'),
7574            id=d.get('id'),
7575            name=d.get('name'),
7576            password=d.get('password'),
7577            port_override=d.get('port_override'),
7578            secret_store_id=d.get('secret_store_id'),
7579            tags=d.get('tags'),
7580            tls_required=d.get('tls_required'),
7581            username=d.get('username'),
7582        )
class Mysql:
7585class Mysql:
7586    __slots__ = [
7587        'bind_interface',
7588        'database',
7589        'egress_filter',
7590        'healthy',
7591        'hostname',
7592        'id',
7593        'name',
7594        'password',
7595        'port',
7596        'port_override',
7597        'secret_store_id',
7598        'tags',
7599        'username',
7600    ]
7601
7602    def __init__(
7603        self,
7604        bind_interface=None,
7605        database=None,
7606        egress_filter=None,
7607        healthy=None,
7608        hostname=None,
7609        id=None,
7610        name=None,
7611        password=None,
7612        port=None,
7613        port_override=None,
7614        secret_store_id=None,
7615        tags=None,
7616        username=None,
7617    ):
7618        self.bind_interface = bind_interface if bind_interface is not None else ''
7619        '''
7620         Bind interface
7621        '''
7622        self.database = database if database is not None else ''
7623        self.egress_filter = egress_filter if egress_filter is not None else ''
7624        '''
7625         A filter applied to the routing logic to pin datasource to nodes.
7626        '''
7627        self.healthy = healthy if healthy is not None else False
7628        '''
7629         True if the datasource is reachable and the credentials are valid.
7630        '''
7631        self.hostname = hostname if hostname is not None else ''
7632        self.id = id if id is not None else ''
7633        '''
7634         Unique identifier of the Resource.
7635        '''
7636        self.name = name if name is not None else ''
7637        '''
7638         Unique human-readable name of the Resource.
7639        '''
7640        self.password = password if password is not None else ''
7641        self.port = port if port is not None else 0
7642        self.port_override = port_override if port_override is not None else 0
7643        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7644        '''
7645         ID of the secret store containing credentials for this resource, if any.
7646        '''
7647        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7648        '''
7649         Tags is a map of key, value pairs.
7650        '''
7651        self.username = username if username is not None else ''
7652
7653    def __repr__(self):
7654        return '<sdm.Mysql ' + \
7655            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7656            'database: ' + repr(self.database) + ' ' +\
7657            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7658            'healthy: ' + repr(self.healthy) + ' ' +\
7659            'hostname: ' + repr(self.hostname) + ' ' +\
7660            'id: ' + repr(self.id) + ' ' +\
7661            'name: ' + repr(self.name) + ' ' +\
7662            'password: ' + repr(self.password) + ' ' +\
7663            'port: ' + repr(self.port) + ' ' +\
7664            'port_override: ' + repr(self.port_override) + ' ' +\
7665            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7666            'tags: ' + repr(self.tags) + ' ' +\
7667            'username: ' + repr(self.username) + ' ' +\
7668            '>'
7669
7670    def to_dict(self):
7671        return {
7672            'bind_interface': self.bind_interface,
7673            'database': self.database,
7674            'egress_filter': self.egress_filter,
7675            'healthy': self.healthy,
7676            'hostname': self.hostname,
7677            'id': self.id,
7678            'name': self.name,
7679            'password': self.password,
7680            'port': self.port,
7681            'port_override': self.port_override,
7682            'secret_store_id': self.secret_store_id,
7683            'tags': self.tags,
7684            'username': self.username,
7685        }
7686
7687    @classmethod
7688    def from_dict(cls, d):
7689        return cls(
7690            bind_interface=d.get('bind_interface'),
7691            database=d.get('database'),
7692            egress_filter=d.get('egress_filter'),
7693            healthy=d.get('healthy'),
7694            hostname=d.get('hostname'),
7695            id=d.get('id'),
7696            name=d.get('name'),
7697            password=d.get('password'),
7698            port=d.get('port'),
7699            port_override=d.get('port_override'),
7700            secret_store_id=d.get('secret_store_id'),
7701            tags=d.get('tags'),
7702            username=d.get('username'),
7703        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7602    def __init__(
7603        self,
7604        bind_interface=None,
7605        database=None,
7606        egress_filter=None,
7607        healthy=None,
7608        hostname=None,
7609        id=None,
7610        name=None,
7611        password=None,
7612        port=None,
7613        port_override=None,
7614        secret_store_id=None,
7615        tags=None,
7616        username=None,
7617    ):
7618        self.bind_interface = bind_interface if bind_interface is not None else ''
7619        '''
7620         Bind interface
7621        '''
7622        self.database = database if database is not None else ''
7623        self.egress_filter = egress_filter if egress_filter is not None else ''
7624        '''
7625         A filter applied to the routing logic to pin datasource to nodes.
7626        '''
7627        self.healthy = healthy if healthy is not None else False
7628        '''
7629         True if the datasource is reachable and the credentials are valid.
7630        '''
7631        self.hostname = hostname if hostname is not None else ''
7632        self.id = id if id is not None else ''
7633        '''
7634         Unique identifier of the Resource.
7635        '''
7636        self.name = name if name is not None else ''
7637        '''
7638         Unique human-readable name of the Resource.
7639        '''
7640        self.password = password if password is not None else ''
7641        self.port = port if port is not None else 0
7642        self.port_override = port_override if port_override is not None else 0
7643        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7644        '''
7645         ID of the secret store containing credentials for this resource, if any.
7646        '''
7647        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7648        '''
7649         Tags is a map of key, value pairs.
7650        '''
7651        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7670    def to_dict(self):
7671        return {
7672            'bind_interface': self.bind_interface,
7673            'database': self.database,
7674            'egress_filter': self.egress_filter,
7675            'healthy': self.healthy,
7676            'hostname': self.hostname,
7677            'id': self.id,
7678            'name': self.name,
7679            'password': self.password,
7680            'port': self.port,
7681            'port_override': self.port_override,
7682            'secret_store_id': self.secret_store_id,
7683            'tags': self.tags,
7684            'username': self.username,
7685        }
@classmethod
def from_dict(cls, d)
7687    @classmethod
7688    def from_dict(cls, d):
7689        return cls(
7690            bind_interface=d.get('bind_interface'),
7691            database=d.get('database'),
7692            egress_filter=d.get('egress_filter'),
7693            healthy=d.get('healthy'),
7694            hostname=d.get('hostname'),
7695            id=d.get('id'),
7696            name=d.get('name'),
7697            password=d.get('password'),
7698            port=d.get('port'),
7699            port_override=d.get('port_override'),
7700            secret_store_id=d.get('secret_store_id'),
7701            tags=d.get('tags'),
7702            username=d.get('username'),
7703        )
class Neptune:
7706class Neptune:
7707    __slots__ = [
7708        'bind_interface',
7709        'egress_filter',
7710        'endpoint',
7711        'healthy',
7712        'id',
7713        'name',
7714        'port',
7715        'port_override',
7716        'secret_store_id',
7717        'tags',
7718    ]
7719
7720    def __init__(
7721        self,
7722        bind_interface=None,
7723        egress_filter=None,
7724        endpoint=None,
7725        healthy=None,
7726        id=None,
7727        name=None,
7728        port=None,
7729        port_override=None,
7730        secret_store_id=None,
7731        tags=None,
7732    ):
7733        self.bind_interface = bind_interface if bind_interface is not None else ''
7734        '''
7735         Bind interface
7736        '''
7737        self.egress_filter = egress_filter if egress_filter is not None else ''
7738        '''
7739         A filter applied to the routing logic to pin datasource to nodes.
7740        '''
7741        self.endpoint = endpoint if endpoint is not None else ''
7742        self.healthy = healthy if healthy is not None else False
7743        '''
7744         True if the datasource is reachable and the credentials are valid.
7745        '''
7746        self.id = id if id is not None else ''
7747        '''
7748         Unique identifier of the Resource.
7749        '''
7750        self.name = name if name is not None else ''
7751        '''
7752         Unique human-readable name of the Resource.
7753        '''
7754        self.port = port if port is not None else 0
7755        self.port_override = port_override if port_override is not None else 0
7756        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7757        '''
7758         ID of the secret store containing credentials for this resource, if any.
7759        '''
7760        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7761        '''
7762         Tags is a map of key, value pairs.
7763        '''
7764
7765    def __repr__(self):
7766        return '<sdm.Neptune ' + \
7767            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7768            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7769            'endpoint: ' + repr(self.endpoint) + ' ' +\
7770            'healthy: ' + repr(self.healthy) + ' ' +\
7771            'id: ' + repr(self.id) + ' ' +\
7772            'name: ' + repr(self.name) + ' ' +\
7773            'port: ' + repr(self.port) + ' ' +\
7774            'port_override: ' + repr(self.port_override) + ' ' +\
7775            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7776            'tags: ' + repr(self.tags) + ' ' +\
7777            '>'
7778
7779    def to_dict(self):
7780        return {
7781            'bind_interface': self.bind_interface,
7782            'egress_filter': self.egress_filter,
7783            'endpoint': self.endpoint,
7784            'healthy': self.healthy,
7785            'id': self.id,
7786            'name': self.name,
7787            'port': self.port,
7788            'port_override': self.port_override,
7789            'secret_store_id': self.secret_store_id,
7790            'tags': self.tags,
7791        }
7792
7793    @classmethod
7794    def from_dict(cls, d):
7795        return cls(
7796            bind_interface=d.get('bind_interface'),
7797            egress_filter=d.get('egress_filter'),
7798            endpoint=d.get('endpoint'),
7799            healthy=d.get('healthy'),
7800            id=d.get('id'),
7801            name=d.get('name'),
7802            port=d.get('port'),
7803            port_override=d.get('port_override'),
7804            secret_store_id=d.get('secret_store_id'),
7805            tags=d.get('tags'),
7806        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7720    def __init__(
7721        self,
7722        bind_interface=None,
7723        egress_filter=None,
7724        endpoint=None,
7725        healthy=None,
7726        id=None,
7727        name=None,
7728        port=None,
7729        port_override=None,
7730        secret_store_id=None,
7731        tags=None,
7732    ):
7733        self.bind_interface = bind_interface if bind_interface is not None else ''
7734        '''
7735         Bind interface
7736        '''
7737        self.egress_filter = egress_filter if egress_filter is not None else ''
7738        '''
7739         A filter applied to the routing logic to pin datasource to nodes.
7740        '''
7741        self.endpoint = endpoint if endpoint is not None else ''
7742        self.healthy = healthy if healthy is not None else False
7743        '''
7744         True if the datasource is reachable and the credentials are valid.
7745        '''
7746        self.id = id if id is not None else ''
7747        '''
7748         Unique identifier of the Resource.
7749        '''
7750        self.name = name if name is not None else ''
7751        '''
7752         Unique human-readable name of the Resource.
7753        '''
7754        self.port = port if port is not None else 0
7755        self.port_override = port_override if port_override is not None else 0
7756        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7757        '''
7758         ID of the secret store containing credentials for this resource, if any.
7759        '''
7760        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7761        '''
7762         Tags is a map of key, value pairs.
7763        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7779    def to_dict(self):
7780        return {
7781            'bind_interface': self.bind_interface,
7782            'egress_filter': self.egress_filter,
7783            'endpoint': self.endpoint,
7784            'healthy': self.healthy,
7785            'id': self.id,
7786            'name': self.name,
7787            'port': self.port,
7788            'port_override': self.port_override,
7789            'secret_store_id': self.secret_store_id,
7790            'tags': self.tags,
7791        }
@classmethod
def from_dict(cls, d)
7793    @classmethod
7794    def from_dict(cls, d):
7795        return cls(
7796            bind_interface=d.get('bind_interface'),
7797            egress_filter=d.get('egress_filter'),
7798            endpoint=d.get('endpoint'),
7799            healthy=d.get('healthy'),
7800            id=d.get('id'),
7801            name=d.get('name'),
7802            port=d.get('port'),
7803            port_override=d.get('port_override'),
7804            secret_store_id=d.get('secret_store_id'),
7805            tags=d.get('tags'),
7806        )
class NeptuneIAM:
7809class NeptuneIAM:
7810    __slots__ = [
7811        'access_key',
7812        'bind_interface',
7813        'egress_filter',
7814        'endpoint',
7815        'healthy',
7816        'id',
7817        'name',
7818        'port',
7819        'port_override',
7820        'region',
7821        'role_arn',
7822        'role_external_id',
7823        'secret_access_key',
7824        'secret_store_id',
7825        'tags',
7826    ]
7827
7828    def __init__(
7829        self,
7830        access_key=None,
7831        bind_interface=None,
7832        egress_filter=None,
7833        endpoint=None,
7834        healthy=None,
7835        id=None,
7836        name=None,
7837        port=None,
7838        port_override=None,
7839        region=None,
7840        role_arn=None,
7841        role_external_id=None,
7842        secret_access_key=None,
7843        secret_store_id=None,
7844        tags=None,
7845    ):
7846        self.access_key = access_key if access_key is not None else ''
7847        self.bind_interface = bind_interface if bind_interface is not None else ''
7848        '''
7849         Bind interface
7850        '''
7851        self.egress_filter = egress_filter if egress_filter is not None else ''
7852        '''
7853         A filter applied to the routing logic to pin datasource to nodes.
7854        '''
7855        self.endpoint = endpoint if endpoint is not None else ''
7856        self.healthy = healthy if healthy is not None else False
7857        '''
7858         True if the datasource is reachable and the credentials are valid.
7859        '''
7860        self.id = id if id is not None else ''
7861        '''
7862         Unique identifier of the Resource.
7863        '''
7864        self.name = name if name is not None else ''
7865        '''
7866         Unique human-readable name of the Resource.
7867        '''
7868        self.port = port if port is not None else 0
7869        self.port_override = port_override if port_override is not None else 0
7870        self.region = region if region is not None else ''
7871        self.role_arn = role_arn if role_arn is not None else ''
7872        self.role_external_id = role_external_id if role_external_id is not None else ''
7873        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
7874        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7875        '''
7876         ID of the secret store containing credentials for this resource, if any.
7877        '''
7878        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7879        '''
7880         Tags is a map of key, value pairs.
7881        '''
7882
7883    def __repr__(self):
7884        return '<sdm.NeptuneIAM ' + \
7885            'access_key: ' + repr(self.access_key) + ' ' +\
7886            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7887            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7888            'endpoint: ' + repr(self.endpoint) + ' ' +\
7889            'healthy: ' + repr(self.healthy) + ' ' +\
7890            'id: ' + repr(self.id) + ' ' +\
7891            'name: ' + repr(self.name) + ' ' +\
7892            'port: ' + repr(self.port) + ' ' +\
7893            'port_override: ' + repr(self.port_override) + ' ' +\
7894            'region: ' + repr(self.region) + ' ' +\
7895            'role_arn: ' + repr(self.role_arn) + ' ' +\
7896            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
7897            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
7898            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7899            'tags: ' + repr(self.tags) + ' ' +\
7900            '>'
7901
7902    def to_dict(self):
7903        return {
7904            'access_key': self.access_key,
7905            'bind_interface': self.bind_interface,
7906            'egress_filter': self.egress_filter,
7907            'endpoint': self.endpoint,
7908            'healthy': self.healthy,
7909            'id': self.id,
7910            'name': self.name,
7911            'port': self.port,
7912            'port_override': self.port_override,
7913            'region': self.region,
7914            'role_arn': self.role_arn,
7915            'role_external_id': self.role_external_id,
7916            'secret_access_key': self.secret_access_key,
7917            'secret_store_id': self.secret_store_id,
7918            'tags': self.tags,
7919        }
7920
7921    @classmethod
7922    def from_dict(cls, d):
7923        return cls(
7924            access_key=d.get('access_key'),
7925            bind_interface=d.get('bind_interface'),
7926            egress_filter=d.get('egress_filter'),
7927            endpoint=d.get('endpoint'),
7928            healthy=d.get('healthy'),
7929            id=d.get('id'),
7930            name=d.get('name'),
7931            port=d.get('port'),
7932            port_override=d.get('port_override'),
7933            region=d.get('region'),
7934            role_arn=d.get('role_arn'),
7935            role_external_id=d.get('role_external_id'),
7936            secret_access_key=d.get('secret_access_key'),
7937            secret_store_id=d.get('secret_store_id'),
7938            tags=d.get('tags'),
7939        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
7828    def __init__(
7829        self,
7830        access_key=None,
7831        bind_interface=None,
7832        egress_filter=None,
7833        endpoint=None,
7834        healthy=None,
7835        id=None,
7836        name=None,
7837        port=None,
7838        port_override=None,
7839        region=None,
7840        role_arn=None,
7841        role_external_id=None,
7842        secret_access_key=None,
7843        secret_store_id=None,
7844        tags=None,
7845    ):
7846        self.access_key = access_key if access_key is not None else ''
7847        self.bind_interface = bind_interface if bind_interface is not None else ''
7848        '''
7849         Bind interface
7850        '''
7851        self.egress_filter = egress_filter if egress_filter is not None else ''
7852        '''
7853         A filter applied to the routing logic to pin datasource to nodes.
7854        '''
7855        self.endpoint = endpoint if endpoint is not None else ''
7856        self.healthy = healthy if healthy is not None else False
7857        '''
7858         True if the datasource is reachable and the credentials are valid.
7859        '''
7860        self.id = id if id is not None else ''
7861        '''
7862         Unique identifier of the Resource.
7863        '''
7864        self.name = name if name is not None else ''
7865        '''
7866         Unique human-readable name of the Resource.
7867        '''
7868        self.port = port if port is not None else 0
7869        self.port_override = port_override if port_override is not None else 0
7870        self.region = region if region is not None else ''
7871        self.role_arn = role_arn if role_arn is not None else ''
7872        self.role_external_id = role_external_id if role_external_id is not None else ''
7873        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
7874        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7875        '''
7876         ID of the secret store containing credentials for this resource, if any.
7877        '''
7878        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7879        '''
7880         Tags is a map of key, value pairs.
7881        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7902    def to_dict(self):
7903        return {
7904            'access_key': self.access_key,
7905            'bind_interface': self.bind_interface,
7906            'egress_filter': self.egress_filter,
7907            'endpoint': self.endpoint,
7908            'healthy': self.healthy,
7909            'id': self.id,
7910            'name': self.name,
7911            'port': self.port,
7912            'port_override': self.port_override,
7913            'region': self.region,
7914            'role_arn': self.role_arn,
7915            'role_external_id': self.role_external_id,
7916            'secret_access_key': self.secret_access_key,
7917            'secret_store_id': self.secret_store_id,
7918            'tags': self.tags,
7919        }
@classmethod
def from_dict(cls, d)
7921    @classmethod
7922    def from_dict(cls, d):
7923        return cls(
7924            access_key=d.get('access_key'),
7925            bind_interface=d.get('bind_interface'),
7926            egress_filter=d.get('egress_filter'),
7927            endpoint=d.get('endpoint'),
7928            healthy=d.get('healthy'),
7929            id=d.get('id'),
7930            name=d.get('name'),
7931            port=d.get('port'),
7932            port_override=d.get('port_override'),
7933            region=d.get('region'),
7934            role_arn=d.get('role_arn'),
7935            role_external_id=d.get('role_external_id'),
7936            secret_access_key=d.get('secret_access_key'),
7937            secret_store_id=d.get('secret_store_id'),
7938            tags=d.get('tags'),
7939        )
class NodeCreateResponse:
7942class NodeCreateResponse:
7943    '''
7944         NodeCreateResponse reports how the Nodes were created in the system.
7945    '''
7946    __slots__ = [
7947        'meta',
7948        'node',
7949        'rate_limit',
7950        'token',
7951    ]
7952
7953    def __init__(
7954        self,
7955        meta=None,
7956        node=None,
7957        rate_limit=None,
7958        token=None,
7959    ):
7960        self.meta = meta if meta is not None else None
7961        '''
7962         Reserved for future use.
7963        '''
7964        self.node = node if node is not None else None
7965        '''
7966         The created Node.
7967        '''
7968        self.rate_limit = rate_limit if rate_limit is not None else None
7969        '''
7970         Rate limit information.
7971        '''
7972        self.token = token if token is not None else ''
7973        '''
7974         The auth token generated for the Node. The Node will use this token to
7975         authenticate with the strongDM API.
7976        '''
7977
7978    def __repr__(self):
7979        return '<sdm.NodeCreateResponse ' + \
7980            'meta: ' + repr(self.meta) + ' ' +\
7981            'node: ' + repr(self.node) + ' ' +\
7982            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
7983            'token: ' + repr(self.token) + ' ' +\
7984            '>'
7985
7986    def to_dict(self):
7987        return {
7988            'meta': self.meta,
7989            'node': self.node,
7990            'rate_limit': self.rate_limit,
7991            'token': self.token,
7992        }
7993
7994    @classmethod
7995    def from_dict(cls, d):
7996        return cls(
7997            meta=d.get('meta'),
7998            node=d.get('node'),
7999            rate_limit=d.get('rate_limit'),
8000            token=d.get('token'),
8001        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
7953    def __init__(
7954        self,
7955        meta=None,
7956        node=None,
7957        rate_limit=None,
7958        token=None,
7959    ):
7960        self.meta = meta if meta is not None else None
7961        '''
7962         Reserved for future use.
7963        '''
7964        self.node = node if node is not None else None
7965        '''
7966         The created Node.
7967        '''
7968        self.rate_limit = rate_limit if rate_limit is not None else None
7969        '''
7970         Rate limit information.
7971        '''
7972        self.token = token if token is not None else ''
7973        '''
7974         The auth token generated for the Node. The Node will use this token to
7975         authenticate with the strongDM API.
7976        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
7986    def to_dict(self):
7987        return {
7988            'meta': self.meta,
7989            'node': self.node,
7990            'rate_limit': self.rate_limit,
7991            'token': self.token,
7992        }
@classmethod
def from_dict(cls, d)
7994    @classmethod
7995    def from_dict(cls, d):
7996        return cls(
7997            meta=d.get('meta'),
7998            node=d.get('node'),
7999            rate_limit=d.get('rate_limit'),
8000            token=d.get('token'),
8001        )
class NodeDeleteResponse:
8004class NodeDeleteResponse:
8005    '''
8006         NodeDeleteResponse returns information about a Node that was deleted.
8007    '''
8008    __slots__ = [
8009        'meta',
8010        'rate_limit',
8011    ]
8012
8013    def __init__(
8014        self,
8015        meta=None,
8016        rate_limit=None,
8017    ):
8018        self.meta = meta if meta is not None else None
8019        '''
8020         Reserved for future use.
8021        '''
8022        self.rate_limit = rate_limit if rate_limit is not None else None
8023        '''
8024         Rate limit information.
8025        '''
8026
8027    def __repr__(self):
8028        return '<sdm.NodeDeleteResponse ' + \
8029            'meta: ' + repr(self.meta) + ' ' +\
8030            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8031            '>'
8032
8033    def to_dict(self):
8034        return {
8035            'meta': self.meta,
8036            'rate_limit': self.rate_limit,
8037        }
8038
8039    @classmethod
8040    def from_dict(cls, d):
8041        return cls(
8042            meta=d.get('meta'),
8043            rate_limit=d.get('rate_limit'),
8044        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
8013    def __init__(
8014        self,
8015        meta=None,
8016        rate_limit=None,
8017    ):
8018        self.meta = meta if meta is not None else None
8019        '''
8020         Reserved for future use.
8021        '''
8022        self.rate_limit = rate_limit if rate_limit is not None else None
8023        '''
8024         Rate limit information.
8025        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
8033    def to_dict(self):
8034        return {
8035            'meta': self.meta,
8036            'rate_limit': self.rate_limit,
8037        }
@classmethod
def from_dict(cls, d)
8039    @classmethod
8040    def from_dict(cls, d):
8041        return cls(
8042            meta=d.get('meta'),
8043            rate_limit=d.get('rate_limit'),
8044        )
class NodeGetResponse:
8047class NodeGetResponse:
8048    '''
8049         NodeGetResponse returns a requested Node.
8050    '''
8051    __slots__ = [
8052        'meta',
8053        'node',
8054        'rate_limit',
8055    ]
8056
8057    def __init__(
8058        self,
8059        meta=None,
8060        node=None,
8061        rate_limit=None,
8062    ):
8063        self.meta = meta if meta is not None else None
8064        '''
8065         Reserved for future use.
8066        '''
8067        self.node = node if node is not None else None
8068        '''
8069         The requested Node.
8070        '''
8071        self.rate_limit = rate_limit if rate_limit is not None else None
8072        '''
8073         Rate limit information.
8074        '''
8075
8076    def __repr__(self):
8077        return '<sdm.NodeGetResponse ' + \
8078            'meta: ' + repr(self.meta) + ' ' +\
8079            'node: ' + repr(self.node) + ' ' +\
8080            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8081            '>'
8082
8083    def to_dict(self):
8084        return {
8085            'meta': self.meta,
8086            'node': self.node,
8087            'rate_limit': self.rate_limit,
8088        }
8089
8090    @classmethod
8091    def from_dict(cls, d):
8092        return cls(
8093            meta=d.get('meta'),
8094            node=d.get('node'),
8095            rate_limit=d.get('rate_limit'),
8096        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
8057    def __init__(
8058        self,
8059        meta=None,
8060        node=None,
8061        rate_limit=None,
8062    ):
8063        self.meta = meta if meta is not None else None
8064        '''
8065         Reserved for future use.
8066        '''
8067        self.node = node if node is not None else None
8068        '''
8069         The requested Node.
8070        '''
8071        self.rate_limit = rate_limit if rate_limit is not None else None
8072        '''
8073         Rate limit information.
8074        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
8083    def to_dict(self):
8084        return {
8085            'meta': self.meta,
8086            'node': self.node,
8087            'rate_limit': self.rate_limit,
8088        }
@classmethod
def from_dict(cls, d)
8090    @classmethod
8091    def from_dict(cls, d):
8092        return cls(
8093            meta=d.get('meta'),
8094            node=d.get('node'),
8095            rate_limit=d.get('rate_limit'),
8096        )
class NodeUpdateResponse:
8099class NodeUpdateResponse:
8100    '''
8101         NodeUpdateResponse returns the fields of a Node after it has been updated by
8102     a NodeUpdateRequest.
8103    '''
8104    __slots__ = [
8105        'meta',
8106        'node',
8107        'rate_limit',
8108    ]
8109
8110    def __init__(
8111        self,
8112        meta=None,
8113        node=None,
8114        rate_limit=None,
8115    ):
8116        self.meta = meta if meta is not None else None
8117        '''
8118         Reserved for future use.
8119        '''
8120        self.node = node if node is not None else None
8121        '''
8122         The updated Node.
8123        '''
8124        self.rate_limit = rate_limit if rate_limit is not None else None
8125        '''
8126         Rate limit information.
8127        '''
8128
8129    def __repr__(self):
8130        return '<sdm.NodeUpdateResponse ' + \
8131            'meta: ' + repr(self.meta) + ' ' +\
8132            'node: ' + repr(self.node) + ' ' +\
8133            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8134            '>'
8135
8136    def to_dict(self):
8137        return {
8138            'meta': self.meta,
8139            'node': self.node,
8140            'rate_limit': self.rate_limit,
8141        }
8142
8143    @classmethod
8144    def from_dict(cls, d):
8145        return cls(
8146            meta=d.get('meta'),
8147            node=d.get('node'),
8148            rate_limit=d.get('rate_limit'),
8149        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
8110    def __init__(
8111        self,
8112        meta=None,
8113        node=None,
8114        rate_limit=None,
8115    ):
8116        self.meta = meta if meta is not None else None
8117        '''
8118         Reserved for future use.
8119        '''
8120        self.node = node if node is not None else None
8121        '''
8122         The updated Node.
8123        '''
8124        self.rate_limit = rate_limit if rate_limit is not None else None
8125        '''
8126         Rate limit information.
8127        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
8136    def to_dict(self):
8137        return {
8138            'meta': self.meta,
8139            'node': self.node,
8140            'rate_limit': self.rate_limit,
8141        }
@classmethod
def from_dict(cls, d)
8143    @classmethod
8144    def from_dict(cls, d):
8145        return cls(
8146            meta=d.get('meta'),
8147            node=d.get('node'),
8148            rate_limit=d.get('rate_limit'),
8149        )
class Oracle:
8152class Oracle:
8153    '''
8154    Oracle is currently unstable, and its API may change, or it may be removed,
8155    without a major version bump.
8156    '''
8157    __slots__ = [
8158        'bind_interface',
8159        'database',
8160        'egress_filter',
8161        'healthy',
8162        'hostname',
8163        'id',
8164        'name',
8165        'password',
8166        'port',
8167        'port_override',
8168        'secret_store_id',
8169        'tags',
8170        'tls_required',
8171        'username',
8172    ]
8173
8174    def __init__(
8175        self,
8176        bind_interface=None,
8177        database=None,
8178        egress_filter=None,
8179        healthy=None,
8180        hostname=None,
8181        id=None,
8182        name=None,
8183        password=None,
8184        port=None,
8185        port_override=None,
8186        secret_store_id=None,
8187        tags=None,
8188        tls_required=None,
8189        username=None,
8190    ):
8191        self.bind_interface = bind_interface if bind_interface is not None else ''
8192        '''
8193         Bind interface
8194        '''
8195        self.database = database if database is not None else ''
8196        self.egress_filter = egress_filter if egress_filter is not None else ''
8197        '''
8198         A filter applied to the routing logic to pin datasource to nodes.
8199        '''
8200        self.healthy = healthy if healthy is not None else False
8201        '''
8202         True if the datasource is reachable and the credentials are valid.
8203        '''
8204        self.hostname = hostname if hostname is not None else ''
8205        self.id = id if id is not None else ''
8206        '''
8207         Unique identifier of the Resource.
8208        '''
8209        self.name = name if name is not None else ''
8210        '''
8211         Unique human-readable name of the Resource.
8212        '''
8213        self.password = password if password is not None else ''
8214        self.port = port if port is not None else 0
8215        self.port_override = port_override if port_override is not None else 0
8216        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8217        '''
8218         ID of the secret store containing credentials for this resource, if any.
8219        '''
8220        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8221        '''
8222         Tags is a map of key, value pairs.
8223        '''
8224        self.tls_required = tls_required if tls_required is not None else False
8225        self.username = username if username is not None else ''
8226
8227    def __repr__(self):
8228        return '<sdm.Oracle ' + \
8229            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8230            'database: ' + repr(self.database) + ' ' +\
8231            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8232            'healthy: ' + repr(self.healthy) + ' ' +\
8233            'hostname: ' + repr(self.hostname) + ' ' +\
8234            'id: ' + repr(self.id) + ' ' +\
8235            'name: ' + repr(self.name) + ' ' +\
8236            'password: ' + repr(self.password) + ' ' +\
8237            'port: ' + repr(self.port) + ' ' +\
8238            'port_override: ' + repr(self.port_override) + ' ' +\
8239            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8240            'tags: ' + repr(self.tags) + ' ' +\
8241            'tls_required: ' + repr(self.tls_required) + ' ' +\
8242            'username: ' + repr(self.username) + ' ' +\
8243            '>'
8244
8245    def to_dict(self):
8246        return {
8247            'bind_interface': self.bind_interface,
8248            'database': self.database,
8249            'egress_filter': self.egress_filter,
8250            'healthy': self.healthy,
8251            'hostname': self.hostname,
8252            'id': self.id,
8253            'name': self.name,
8254            'password': self.password,
8255            'port': self.port,
8256            'port_override': self.port_override,
8257            'secret_store_id': self.secret_store_id,
8258            'tags': self.tags,
8259            'tls_required': self.tls_required,
8260            'username': self.username,
8261        }
8262
8263    @classmethod
8264    def from_dict(cls, d):
8265        return cls(
8266            bind_interface=d.get('bind_interface'),
8267            database=d.get('database'),
8268            egress_filter=d.get('egress_filter'),
8269            healthy=d.get('healthy'),
8270            hostname=d.get('hostname'),
8271            id=d.get('id'),
8272            name=d.get('name'),
8273            password=d.get('password'),
8274            port=d.get('port'),
8275            port_override=d.get('port_override'),
8276            secret_store_id=d.get('secret_store_id'),
8277            tags=d.get('tags'),
8278            tls_required=d.get('tls_required'),
8279            username=d.get('username'),
8280        )

Oracle is currently unstable, and its API may change, or it may be removed, without a major version bump.

Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8174    def __init__(
8175        self,
8176        bind_interface=None,
8177        database=None,
8178        egress_filter=None,
8179        healthy=None,
8180        hostname=None,
8181        id=None,
8182        name=None,
8183        password=None,
8184        port=None,
8185        port_override=None,
8186        secret_store_id=None,
8187        tags=None,
8188        tls_required=None,
8189        username=None,
8190    ):
8191        self.bind_interface = bind_interface if bind_interface is not None else ''
8192        '''
8193         Bind interface
8194        '''
8195        self.database = database if database is not None else ''
8196        self.egress_filter = egress_filter if egress_filter is not None else ''
8197        '''
8198         A filter applied to the routing logic to pin datasource to nodes.
8199        '''
8200        self.healthy = healthy if healthy is not None else False
8201        '''
8202         True if the datasource is reachable and the credentials are valid.
8203        '''
8204        self.hostname = hostname if hostname is not None else ''
8205        self.id = id if id is not None else ''
8206        '''
8207         Unique identifier of the Resource.
8208        '''
8209        self.name = name if name is not None else ''
8210        '''
8211         Unique human-readable name of the Resource.
8212        '''
8213        self.password = password if password is not None else ''
8214        self.port = port if port is not None else 0
8215        self.port_override = port_override if port_override is not None else 0
8216        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8217        '''
8218         ID of the secret store containing credentials for this resource, if any.
8219        '''
8220        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8221        '''
8222         Tags is a map of key, value pairs.
8223        '''
8224        self.tls_required = tls_required if tls_required is not None else False
8225        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8245    def to_dict(self):
8246        return {
8247            'bind_interface': self.bind_interface,
8248            'database': self.database,
8249            'egress_filter': self.egress_filter,
8250            'healthy': self.healthy,
8251            'hostname': self.hostname,
8252            'id': self.id,
8253            'name': self.name,
8254            'password': self.password,
8255            'port': self.port,
8256            'port_override': self.port_override,
8257            'secret_store_id': self.secret_store_id,
8258            'tags': self.tags,
8259            'tls_required': self.tls_required,
8260            'username': self.username,
8261        }
@classmethod
def from_dict(cls, d)
8263    @classmethod
8264    def from_dict(cls, d):
8265        return cls(
8266            bind_interface=d.get('bind_interface'),
8267            database=d.get('database'),
8268            egress_filter=d.get('egress_filter'),
8269            healthy=d.get('healthy'),
8270            hostname=d.get('hostname'),
8271            id=d.get('id'),
8272            name=d.get('name'),
8273            password=d.get('password'),
8274            port=d.get('port'),
8275            port_override=d.get('port_override'),
8276            secret_store_id=d.get('secret_store_id'),
8277            tags=d.get('tags'),
8278            tls_required=d.get('tls_required'),
8279            username=d.get('username'),
8280        )
class Postgres:
8283class Postgres:
8284    __slots__ = [
8285        'bind_interface',
8286        'database',
8287        'egress_filter',
8288        'healthy',
8289        'hostname',
8290        'id',
8291        'name',
8292        'override_database',
8293        'password',
8294        'port',
8295        'port_override',
8296        'secret_store_id',
8297        'tags',
8298        'username',
8299    ]
8300
8301    def __init__(
8302        self,
8303        bind_interface=None,
8304        database=None,
8305        egress_filter=None,
8306        healthy=None,
8307        hostname=None,
8308        id=None,
8309        name=None,
8310        override_database=None,
8311        password=None,
8312        port=None,
8313        port_override=None,
8314        secret_store_id=None,
8315        tags=None,
8316        username=None,
8317    ):
8318        self.bind_interface = bind_interface if bind_interface is not None else ''
8319        '''
8320         Bind interface
8321        '''
8322        self.database = database if database is not None else ''
8323        self.egress_filter = egress_filter if egress_filter is not None else ''
8324        '''
8325         A filter applied to the routing logic to pin datasource to nodes.
8326        '''
8327        self.healthy = healthy if healthy is not None else False
8328        '''
8329         True if the datasource is reachable and the credentials are valid.
8330        '''
8331        self.hostname = hostname if hostname is not None else ''
8332        self.id = id if id is not None else ''
8333        '''
8334         Unique identifier of the Resource.
8335        '''
8336        self.name = name if name is not None else ''
8337        '''
8338         Unique human-readable name of the Resource.
8339        '''
8340        self.override_database = override_database if override_database is not None else False
8341        self.password = password if password is not None else ''
8342        self.port = port if port is not None else 0
8343        self.port_override = port_override if port_override is not None else 0
8344        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8345        '''
8346         ID of the secret store containing credentials for this resource, if any.
8347        '''
8348        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8349        '''
8350         Tags is a map of key, value pairs.
8351        '''
8352        self.username = username if username is not None else ''
8353
8354    def __repr__(self):
8355        return '<sdm.Postgres ' + \
8356            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8357            'database: ' + repr(self.database) + ' ' +\
8358            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8359            'healthy: ' + repr(self.healthy) + ' ' +\
8360            'hostname: ' + repr(self.hostname) + ' ' +\
8361            'id: ' + repr(self.id) + ' ' +\
8362            'name: ' + repr(self.name) + ' ' +\
8363            'override_database: ' + repr(self.override_database) + ' ' +\
8364            'password: ' + repr(self.password) + ' ' +\
8365            'port: ' + repr(self.port) + ' ' +\
8366            'port_override: ' + repr(self.port_override) + ' ' +\
8367            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8368            'tags: ' + repr(self.tags) + ' ' +\
8369            'username: ' + repr(self.username) + ' ' +\
8370            '>'
8371
8372    def to_dict(self):
8373        return {
8374            'bind_interface': self.bind_interface,
8375            'database': self.database,
8376            'egress_filter': self.egress_filter,
8377            'healthy': self.healthy,
8378            'hostname': self.hostname,
8379            'id': self.id,
8380            'name': self.name,
8381            'override_database': self.override_database,
8382            'password': self.password,
8383            'port': self.port,
8384            'port_override': self.port_override,
8385            'secret_store_id': self.secret_store_id,
8386            'tags': self.tags,
8387            'username': self.username,
8388        }
8389
8390    @classmethod
8391    def from_dict(cls, d):
8392        return cls(
8393            bind_interface=d.get('bind_interface'),
8394            database=d.get('database'),
8395            egress_filter=d.get('egress_filter'),
8396            healthy=d.get('healthy'),
8397            hostname=d.get('hostname'),
8398            id=d.get('id'),
8399            name=d.get('name'),
8400            override_database=d.get('override_database'),
8401            password=d.get('password'),
8402            port=d.get('port'),
8403            port_override=d.get('port_override'),
8404            secret_store_id=d.get('secret_store_id'),
8405            tags=d.get('tags'),
8406            username=d.get('username'),
8407        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8301    def __init__(
8302        self,
8303        bind_interface=None,
8304        database=None,
8305        egress_filter=None,
8306        healthy=None,
8307        hostname=None,
8308        id=None,
8309        name=None,
8310        override_database=None,
8311        password=None,
8312        port=None,
8313        port_override=None,
8314        secret_store_id=None,
8315        tags=None,
8316        username=None,
8317    ):
8318        self.bind_interface = bind_interface if bind_interface is not None else ''
8319        '''
8320         Bind interface
8321        '''
8322        self.database = database if database is not None else ''
8323        self.egress_filter = egress_filter if egress_filter is not None else ''
8324        '''
8325         A filter applied to the routing logic to pin datasource to nodes.
8326        '''
8327        self.healthy = healthy if healthy is not None else False
8328        '''
8329         True if the datasource is reachable and the credentials are valid.
8330        '''
8331        self.hostname = hostname if hostname is not None else ''
8332        self.id = id if id is not None else ''
8333        '''
8334         Unique identifier of the Resource.
8335        '''
8336        self.name = name if name is not None else ''
8337        '''
8338         Unique human-readable name of the Resource.
8339        '''
8340        self.override_database = override_database if override_database is not None else False
8341        self.password = password if password is not None else ''
8342        self.port = port if port is not None else 0
8343        self.port_override = port_override if port_override is not None else 0
8344        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8345        '''
8346         ID of the secret store containing credentials for this resource, if any.
8347        '''
8348        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8349        '''
8350         Tags is a map of key, value pairs.
8351        '''
8352        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8372    def to_dict(self):
8373        return {
8374            'bind_interface': self.bind_interface,
8375            'database': self.database,
8376            'egress_filter': self.egress_filter,
8377            'healthy': self.healthy,
8378            'hostname': self.hostname,
8379            'id': self.id,
8380            'name': self.name,
8381            'override_database': self.override_database,
8382            'password': self.password,
8383            'port': self.port,
8384            'port_override': self.port_override,
8385            'secret_store_id': self.secret_store_id,
8386            'tags': self.tags,
8387            'username': self.username,
8388        }
@classmethod
def from_dict(cls, d)
8390    @classmethod
8391    def from_dict(cls, d):
8392        return cls(
8393            bind_interface=d.get('bind_interface'),
8394            database=d.get('database'),
8395            egress_filter=d.get('egress_filter'),
8396            healthy=d.get('healthy'),
8397            hostname=d.get('hostname'),
8398            id=d.get('id'),
8399            name=d.get('name'),
8400            override_database=d.get('override_database'),
8401            password=d.get('password'),
8402            port=d.get('port'),
8403            port_override=d.get('port_override'),
8404            secret_store_id=d.get('secret_store_id'),
8405            tags=d.get('tags'),
8406            username=d.get('username'),
8407        )
class Presto:
8410class Presto:
8411    __slots__ = [
8412        'bind_interface',
8413        'database',
8414        'egress_filter',
8415        'healthy',
8416        'hostname',
8417        'id',
8418        'name',
8419        'password',
8420        'port',
8421        'port_override',
8422        'secret_store_id',
8423        'tags',
8424        'tls_required',
8425        'username',
8426    ]
8427
8428    def __init__(
8429        self,
8430        bind_interface=None,
8431        database=None,
8432        egress_filter=None,
8433        healthy=None,
8434        hostname=None,
8435        id=None,
8436        name=None,
8437        password=None,
8438        port=None,
8439        port_override=None,
8440        secret_store_id=None,
8441        tags=None,
8442        tls_required=None,
8443        username=None,
8444    ):
8445        self.bind_interface = bind_interface if bind_interface is not None else ''
8446        '''
8447         Bind interface
8448        '''
8449        self.database = database if database is not None else ''
8450        self.egress_filter = egress_filter if egress_filter is not None else ''
8451        '''
8452         A filter applied to the routing logic to pin datasource to nodes.
8453        '''
8454        self.healthy = healthy if healthy is not None else False
8455        '''
8456         True if the datasource is reachable and the credentials are valid.
8457        '''
8458        self.hostname = hostname if hostname is not None else ''
8459        self.id = id if id is not None else ''
8460        '''
8461         Unique identifier of the Resource.
8462        '''
8463        self.name = name if name is not None else ''
8464        '''
8465         Unique human-readable name of the Resource.
8466        '''
8467        self.password = password if password is not None else ''
8468        self.port = port if port is not None else 0
8469        self.port_override = port_override if port_override is not None else 0
8470        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8471        '''
8472         ID of the secret store containing credentials for this resource, if any.
8473        '''
8474        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8475        '''
8476         Tags is a map of key, value pairs.
8477        '''
8478        self.tls_required = tls_required if tls_required is not None else False
8479        self.username = username if username is not None else ''
8480
8481    def __repr__(self):
8482        return '<sdm.Presto ' + \
8483            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8484            'database: ' + repr(self.database) + ' ' +\
8485            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8486            'healthy: ' + repr(self.healthy) + ' ' +\
8487            'hostname: ' + repr(self.hostname) + ' ' +\
8488            'id: ' + repr(self.id) + ' ' +\
8489            'name: ' + repr(self.name) + ' ' +\
8490            'password: ' + repr(self.password) + ' ' +\
8491            'port: ' + repr(self.port) + ' ' +\
8492            'port_override: ' + repr(self.port_override) + ' ' +\
8493            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8494            'tags: ' + repr(self.tags) + ' ' +\
8495            'tls_required: ' + repr(self.tls_required) + ' ' +\
8496            'username: ' + repr(self.username) + ' ' +\
8497            '>'
8498
8499    def to_dict(self):
8500        return {
8501            'bind_interface': self.bind_interface,
8502            'database': self.database,
8503            'egress_filter': self.egress_filter,
8504            'healthy': self.healthy,
8505            'hostname': self.hostname,
8506            'id': self.id,
8507            'name': self.name,
8508            'password': self.password,
8509            'port': self.port,
8510            'port_override': self.port_override,
8511            'secret_store_id': self.secret_store_id,
8512            'tags': self.tags,
8513            'tls_required': self.tls_required,
8514            'username': self.username,
8515        }
8516
8517    @classmethod
8518    def from_dict(cls, d):
8519        return cls(
8520            bind_interface=d.get('bind_interface'),
8521            database=d.get('database'),
8522            egress_filter=d.get('egress_filter'),
8523            healthy=d.get('healthy'),
8524            hostname=d.get('hostname'),
8525            id=d.get('id'),
8526            name=d.get('name'),
8527            password=d.get('password'),
8528            port=d.get('port'),
8529            port_override=d.get('port_override'),
8530            secret_store_id=d.get('secret_store_id'),
8531            tags=d.get('tags'),
8532            tls_required=d.get('tls_required'),
8533            username=d.get('username'),
8534        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8428    def __init__(
8429        self,
8430        bind_interface=None,
8431        database=None,
8432        egress_filter=None,
8433        healthy=None,
8434        hostname=None,
8435        id=None,
8436        name=None,
8437        password=None,
8438        port=None,
8439        port_override=None,
8440        secret_store_id=None,
8441        tags=None,
8442        tls_required=None,
8443        username=None,
8444    ):
8445        self.bind_interface = bind_interface if bind_interface is not None else ''
8446        '''
8447         Bind interface
8448        '''
8449        self.database = database if database is not None else ''
8450        self.egress_filter = egress_filter if egress_filter is not None else ''
8451        '''
8452         A filter applied to the routing logic to pin datasource to nodes.
8453        '''
8454        self.healthy = healthy if healthy is not None else False
8455        '''
8456         True if the datasource is reachable and the credentials are valid.
8457        '''
8458        self.hostname = hostname if hostname is not None else ''
8459        self.id = id if id is not None else ''
8460        '''
8461         Unique identifier of the Resource.
8462        '''
8463        self.name = name if name is not None else ''
8464        '''
8465         Unique human-readable name of the Resource.
8466        '''
8467        self.password = password if password is not None else ''
8468        self.port = port if port is not None else 0
8469        self.port_override = port_override if port_override is not None else 0
8470        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8471        '''
8472         ID of the secret store containing credentials for this resource, if any.
8473        '''
8474        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8475        '''
8476         Tags is a map of key, value pairs.
8477        '''
8478        self.tls_required = tls_required if tls_required is not None else False
8479        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8499    def to_dict(self):
8500        return {
8501            'bind_interface': self.bind_interface,
8502            'database': self.database,
8503            'egress_filter': self.egress_filter,
8504            'healthy': self.healthy,
8505            'hostname': self.hostname,
8506            'id': self.id,
8507            'name': self.name,
8508            'password': self.password,
8509            'port': self.port,
8510            'port_override': self.port_override,
8511            'secret_store_id': self.secret_store_id,
8512            'tags': self.tags,
8513            'tls_required': self.tls_required,
8514            'username': self.username,
8515        }
@classmethod
def from_dict(cls, d)
8517    @classmethod
8518    def from_dict(cls, d):
8519        return cls(
8520            bind_interface=d.get('bind_interface'),
8521            database=d.get('database'),
8522            egress_filter=d.get('egress_filter'),
8523            healthy=d.get('healthy'),
8524            hostname=d.get('hostname'),
8525            id=d.get('id'),
8526            name=d.get('name'),
8527            password=d.get('password'),
8528            port=d.get('port'),
8529            port_override=d.get('port_override'),
8530            secret_store_id=d.get('secret_store_id'),
8531            tags=d.get('tags'),
8532            tls_required=d.get('tls_required'),
8533            username=d.get('username'),
8534        )
class RDP:
8537class RDP:
8538    __slots__ = [
8539        'bind_interface',
8540        'downgrade_nla_connections',
8541        'egress_filter',
8542        'healthy',
8543        'hostname',
8544        'id',
8545        'name',
8546        'password',
8547        'port',
8548        'port_override',
8549        'secret_store_id',
8550        'tags',
8551        'username',
8552    ]
8553
8554    def __init__(
8555        self,
8556        bind_interface=None,
8557        downgrade_nla_connections=None,
8558        egress_filter=None,
8559        healthy=None,
8560        hostname=None,
8561        id=None,
8562        name=None,
8563        password=None,
8564        port=None,
8565        port_override=None,
8566        secret_store_id=None,
8567        tags=None,
8568        username=None,
8569    ):
8570        self.bind_interface = bind_interface if bind_interface is not None else ''
8571        '''
8572         Bind interface
8573        '''
8574        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
8575        self.egress_filter = egress_filter if egress_filter is not None else ''
8576        '''
8577         A filter applied to the routing logic to pin datasource to nodes.
8578        '''
8579        self.healthy = healthy if healthy is not None else False
8580        '''
8581         True if the datasource is reachable and the credentials are valid.
8582        '''
8583        self.hostname = hostname if hostname is not None else ''
8584        self.id = id if id is not None else ''
8585        '''
8586         Unique identifier of the Resource.
8587        '''
8588        self.name = name if name is not None else ''
8589        '''
8590         Unique human-readable name of the Resource.
8591        '''
8592        self.password = password if password is not None else ''
8593        self.port = port if port is not None else 0
8594        self.port_override = port_override if port_override is not None else 0
8595        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8596        '''
8597         ID of the secret store containing credentials for this resource, if any.
8598        '''
8599        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8600        '''
8601         Tags is a map of key, value pairs.
8602        '''
8603        self.username = username if username is not None else ''
8604
8605    def __repr__(self):
8606        return '<sdm.RDP ' + \
8607            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8608            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
8609            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8610            'healthy: ' + repr(self.healthy) + ' ' +\
8611            'hostname: ' + repr(self.hostname) + ' ' +\
8612            'id: ' + repr(self.id) + ' ' +\
8613            'name: ' + repr(self.name) + ' ' +\
8614            'password: ' + repr(self.password) + ' ' +\
8615            'port: ' + repr(self.port) + ' ' +\
8616            'port_override: ' + repr(self.port_override) + ' ' +\
8617            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8618            'tags: ' + repr(self.tags) + ' ' +\
8619            'username: ' + repr(self.username) + ' ' +\
8620            '>'
8621
8622    def to_dict(self):
8623        return {
8624            'bind_interface': self.bind_interface,
8625            'downgrade_nla_connections': self.downgrade_nla_connections,
8626            'egress_filter': self.egress_filter,
8627            'healthy': self.healthy,
8628            'hostname': self.hostname,
8629            'id': self.id,
8630            'name': self.name,
8631            'password': self.password,
8632            'port': self.port,
8633            'port_override': self.port_override,
8634            'secret_store_id': self.secret_store_id,
8635            'tags': self.tags,
8636            'username': self.username,
8637        }
8638
8639    @classmethod
8640    def from_dict(cls, d):
8641        return cls(
8642            bind_interface=d.get('bind_interface'),
8643            downgrade_nla_connections=d.get('downgrade_nla_connections'),
8644            egress_filter=d.get('egress_filter'),
8645            healthy=d.get('healthy'),
8646            hostname=d.get('hostname'),
8647            id=d.get('id'),
8648            name=d.get('name'),
8649            password=d.get('password'),
8650            port=d.get('port'),
8651            port_override=d.get('port_override'),
8652            secret_store_id=d.get('secret_store_id'),
8653            tags=d.get('tags'),
8654            username=d.get('username'),
8655        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8554    def __init__(
8555        self,
8556        bind_interface=None,
8557        downgrade_nla_connections=None,
8558        egress_filter=None,
8559        healthy=None,
8560        hostname=None,
8561        id=None,
8562        name=None,
8563        password=None,
8564        port=None,
8565        port_override=None,
8566        secret_store_id=None,
8567        tags=None,
8568        username=None,
8569    ):
8570        self.bind_interface = bind_interface if bind_interface is not None else ''
8571        '''
8572         Bind interface
8573        '''
8574        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
8575        self.egress_filter = egress_filter if egress_filter is not None else ''
8576        '''
8577         A filter applied to the routing logic to pin datasource to nodes.
8578        '''
8579        self.healthy = healthy if healthy is not None else False
8580        '''
8581         True if the datasource is reachable and the credentials are valid.
8582        '''
8583        self.hostname = hostname if hostname is not None else ''
8584        self.id = id if id is not None else ''
8585        '''
8586         Unique identifier of the Resource.
8587        '''
8588        self.name = name if name is not None else ''
8589        '''
8590         Unique human-readable name of the Resource.
8591        '''
8592        self.password = password if password is not None else ''
8593        self.port = port if port is not None else 0
8594        self.port_override = port_override if port_override is not None else 0
8595        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8596        '''
8597         ID of the secret store containing credentials for this resource, if any.
8598        '''
8599        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8600        '''
8601         Tags is a map of key, value pairs.
8602        '''
8603        self.username = username if username is not None else ''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8622    def to_dict(self):
8623        return {
8624            'bind_interface': self.bind_interface,
8625            'downgrade_nla_connections': self.downgrade_nla_connections,
8626            'egress_filter': self.egress_filter,
8627            'healthy': self.healthy,
8628            'hostname': self.hostname,
8629            'id': self.id,
8630            'name': self.name,
8631            'password': self.password,
8632            'port': self.port,
8633            'port_override': self.port_override,
8634            'secret_store_id': self.secret_store_id,
8635            'tags': self.tags,
8636            'username': self.username,
8637        }
@classmethod
def from_dict(cls, d)
8639    @classmethod
8640    def from_dict(cls, d):
8641        return cls(
8642            bind_interface=d.get('bind_interface'),
8643            downgrade_nla_connections=d.get('downgrade_nla_connections'),
8644            egress_filter=d.get('egress_filter'),
8645            healthy=d.get('healthy'),
8646            hostname=d.get('hostname'),
8647            id=d.get('id'),
8648            name=d.get('name'),
8649            password=d.get('password'),
8650            port=d.get('port'),
8651            port_override=d.get('port_override'),
8652            secret_store_id=d.get('secret_store_id'),
8653            tags=d.get('tags'),
8654            username=d.get('username'),
8655        )
class RabbitMQAMQP091:
8658class RabbitMQAMQP091:
8659    __slots__ = [
8660        'bind_interface',
8661        'egress_filter',
8662        'healthy',
8663        'hostname',
8664        'id',
8665        'name',
8666        'password',
8667        'port',
8668        'port_override',
8669        'secret_store_id',
8670        'tags',
8671        'tls_required',
8672        'username',
8673    ]
8674
8675    def __init__(
8676        self,
8677        bind_interface=None,
8678        egress_filter=None,
8679        healthy=None,
8680        hostname=None,
8681        id=None,
8682        name=None,
8683        password=None,
8684        port=None,
8685        port_override=None,
8686        secret_store_id=None,
8687        tags=None,
8688        tls_required=None,
8689        username=None,
8690    ):
8691        self.bind_interface = bind_interface if bind_interface is not None else ''
8692        '''
8693         Bind interface
8694        '''
8695        self.egress_filter = egress_filter if egress_filter is not None else ''
8696        '''
8697         A filter applied to the routing logic to pin datasource to nodes.
8698        '''
8699        self.healthy = healthy if healthy is not None else False
8700        '''
8701         True if the datasource is reachable and the credentials are valid.
8702        '''
8703        self.hostname = hostname if hostname is not None else ''
8704        self.id = id if id is not None else ''
8705        '''
8706         Unique identifier of the Resource.
8707        '''
8708        self.name = name if name is not None else ''
8709        '''
8710         Unique human-readable name of the Resource.
8711        '''
8712        self.password = password if password is not None else ''
8713        self.port = port if port is not None else 0
8714        self.port_override = port_override if port_override is not None else 0
8715        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8716        '''
8717         ID of the secret store containing credentials for this resource, if any.
8718        '''
8719        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8720        '''
8721         Tags is a map of key, value pairs.
8722        '''
8723        self.tls_required = tls_required if tls_required is not None else False
8724        self.username = username if username is not None else ''
8725
8726    def __repr__(self):
8727        return '<sdm.RabbitMQAMQP091 ' + \
8728            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8729            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8730            'healthy: ' + repr(self.healthy) + ' ' +\
8731            'hostname: ' + repr(self.hostname) + ' ' +\
8732            'id: ' + repr(self.id) + ' ' +\
8733            'name: ' + repr(self.name) + ' ' +\
8734            'password: ' + repr(self.password) + ' ' +\
8735            'port: ' + repr(self.port) + ' ' +\
8736            'port_override: ' + repr(self.port_override) + ' ' +\
8737            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8738            'tags: ' + repr(self.tags) + ' ' +\
8739            'tls_required: ' + repr(self.tls_required) + ' ' +\
8740            'username: ' + repr(self.username) + ' ' +\
8741            '>'
8742
8743    def to_dict(self):
8744        return {
8745            'bind_interface': self.bind_interface,
8746            'egress_filter': self.egress_filter,
8747            'healthy': self.healthy,
8748            'hostname': self.hostname,
8749            'id': self.id,
8750            'name': self.name,
8751            'password': self.password,
8752            'port': self.port,
8753            'port_override': self.port_override,
8754            'secret_store_id': self.secret_store_id,
8755            'tags': self.tags,
8756            'tls_required': self.tls_required,
8757            'username': self.username,
8758        }
8759
8760    @classmethod
8761    def from_dict(cls, d):
8762        return cls(
8763            bind_interface=d.get('bind_interface'),
8764            egress_filter=d.get('egress_filter'),
8765            healthy=d.get('healthy'),
8766            hostname=d.get('hostname'),
8767            id=d.get('id'),
8768            name=d.get('name'),
8769            password=d.get('password'),
8770            port=d.get('port'),
8771            port_override=d.get('port_override'),
8772            secret_store_id=d.get('secret_store_id'),
8773            tags=d.get('tags'),
8774            tls_required=d.get('tls_required'),
8775            username=d.get('username'),
8776        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8675    def __init__(
8676        self,
8677        bind_interface=None,
8678        egress_filter=None,
8679        healthy=None,
8680        hostname=None,
8681        id=None,
8682        name=None,
8683        password=None,
8684        port=None,
8685        port_override=None,
8686        secret_store_id=None,
8687        tags=None,
8688        tls_required=None,
8689        username=None,
8690    ):
8691        self.bind_interface = bind_interface if bind_interface is not None else ''
8692        '''
8693         Bind interface
8694        '''
8695        self.egress_filter = egress_filter if egress_filter is not None else ''
8696        '''
8697         A filter applied to the routing logic to pin datasource to nodes.
8698        '''
8699        self.healthy = healthy if healthy is not None else False
8700        '''
8701         True if the datasource is reachable and the credentials are valid.
8702        '''
8703        self.hostname = hostname if hostname is not None else ''
8704        self.id = id if id is not None else ''
8705        '''
8706         Unique identifier of the Resource.
8707        '''
8708        self.name = name if name is not None else ''
8709        '''
8710         Unique human-readable name of the Resource.
8711        '''
8712        self.password = password if password is not None else ''
8713        self.port = port if port is not None else 0
8714        self.port_override = port_override if port_override is not None else 0
8715        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8716        '''
8717         ID of the secret store containing credentials for this resource, if any.
8718        '''
8719        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8720        '''
8721         Tags is a map of key, value pairs.
8722        '''
8723        self.tls_required = tls_required if tls_required is not None else False
8724        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8743    def to_dict(self):
8744        return {
8745            'bind_interface': self.bind_interface,
8746            'egress_filter': self.egress_filter,
8747            'healthy': self.healthy,
8748            'hostname': self.hostname,
8749            'id': self.id,
8750            'name': self.name,
8751            'password': self.password,
8752            'port': self.port,
8753            'port_override': self.port_override,
8754            'secret_store_id': self.secret_store_id,
8755            'tags': self.tags,
8756            'tls_required': self.tls_required,
8757            'username': self.username,
8758        }
@classmethod
def from_dict(cls, d)
8760    @classmethod
8761    def from_dict(cls, d):
8762        return cls(
8763            bind_interface=d.get('bind_interface'),
8764            egress_filter=d.get('egress_filter'),
8765            healthy=d.get('healthy'),
8766            hostname=d.get('hostname'),
8767            id=d.get('id'),
8768            name=d.get('name'),
8769            password=d.get('password'),
8770            port=d.get('port'),
8771            port_override=d.get('port_override'),
8772            secret_store_id=d.get('secret_store_id'),
8773            tags=d.get('tags'),
8774            tls_required=d.get('tls_required'),
8775            username=d.get('username'),
8776        )
class RateLimitMetadata:
8779class RateLimitMetadata:
8780    '''
8781         RateLimitMetadata contains information about remaining requests avaialable
8782     to the user over some timeframe.
8783    '''
8784    __slots__ = [
8785        'bucket',
8786        'limit',
8787        'remaining',
8788        'reset_at',
8789    ]
8790
8791    def __init__(
8792        self,
8793        bucket=None,
8794        limit=None,
8795        remaining=None,
8796        reset_at=None,
8797    ):
8798        self.bucket = bucket if bucket is not None else ''
8799        '''
8800         The bucket this user/token is associated with, which may be shared between
8801         multiple users/tokens.
8802        '''
8803        self.limit = limit if limit is not None else 0
8804        '''
8805         How many total requests the user/token is authorized to make before being
8806         rate limited.
8807        '''
8808        self.remaining = remaining if remaining is not None else 0
8809        '''
8810         How many remaining requests out of the limit are still avaialable.
8811        '''
8812        self.reset_at = reset_at if reset_at is not None else None
8813        '''
8814         The time when remaining will be reset to limit.
8815        '''
8816
8817    def __repr__(self):
8818        return '<sdm.RateLimitMetadata ' + \
8819            'bucket: ' + repr(self.bucket) + ' ' +\
8820            'limit: ' + repr(self.limit) + ' ' +\
8821            'remaining: ' + repr(self.remaining) + ' ' +\
8822            'reset_at: ' + repr(self.reset_at) + ' ' +\
8823            '>'
8824
8825    def to_dict(self):
8826        return {
8827            'bucket': self.bucket,
8828            'limit': self.limit,
8829            'remaining': self.remaining,
8830            'reset_at': self.reset_at,
8831        }
8832
8833    @classmethod
8834    def from_dict(cls, d):
8835        return cls(
8836            bucket=d.get('bucket'),
8837            limit=d.get('limit'),
8838            remaining=d.get('remaining'),
8839            reset_at=d.get('reset_at'),
8840        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
8791    def __init__(
8792        self,
8793        bucket=None,
8794        limit=None,
8795        remaining=None,
8796        reset_at=None,
8797    ):
8798        self.bucket = bucket if bucket is not None else ''
8799        '''
8800         The bucket this user/token is associated with, which may be shared between
8801         multiple users/tokens.
8802        '''
8803        self.limit = limit if limit is not None else 0
8804        '''
8805         How many total requests the user/token is authorized to make before being
8806         rate limited.
8807        '''
8808        self.remaining = remaining if remaining is not None else 0
8809        '''
8810         How many remaining requests out of the limit are still avaialable.
8811        '''
8812        self.reset_at = reset_at if reset_at is not None else None
8813        '''
8814         The time when remaining will be reset to limit.
8815        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
8825    def to_dict(self):
8826        return {
8827            'bucket': self.bucket,
8828            'limit': self.limit,
8829            'remaining': self.remaining,
8830            'reset_at': self.reset_at,
8831        }
@classmethod
def from_dict(cls, d)
8833    @classmethod
8834    def from_dict(cls, d):
8835        return cls(
8836            bucket=d.get('bucket'),
8837            limit=d.get('limit'),
8838            remaining=d.get('remaining'),
8839            reset_at=d.get('reset_at'),
8840        )
class RawTCP:
8843class RawTCP:
8844    __slots__ = [
8845        'bind_interface',
8846        'egress_filter',
8847        'healthy',
8848        'hostname',
8849        'id',
8850        'name',
8851        'port',
8852        'port_override',
8853        'secret_store_id',
8854        'tags',
8855    ]
8856
8857    def __init__(
8858        self,
8859        bind_interface=None,
8860        egress_filter=None,
8861        healthy=None,
8862        hostname=None,
8863        id=None,
8864        name=None,
8865        port=None,
8866        port_override=None,
8867        secret_store_id=None,
8868        tags=None,
8869    ):
8870        self.bind_interface = bind_interface if bind_interface is not None else ''
8871        '''
8872         Bind interface
8873        '''
8874        self.egress_filter = egress_filter if egress_filter is not None else ''
8875        '''
8876         A filter applied to the routing logic to pin datasource to nodes.
8877        '''
8878        self.healthy = healthy if healthy is not None else False
8879        '''
8880         True if the datasource is reachable and the credentials are valid.
8881        '''
8882        self.hostname = hostname if hostname is not None else ''
8883        self.id = id if id is not None else ''
8884        '''
8885         Unique identifier of the Resource.
8886        '''
8887        self.name = name if name is not None else ''
8888        '''
8889         Unique human-readable name of the Resource.
8890        '''
8891        self.port = port if port is not None else 0
8892        self.port_override = port_override if port_override is not None else 0
8893        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8894        '''
8895         ID of the secret store containing credentials for this resource, if any.
8896        '''
8897        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8898        '''
8899         Tags is a map of key, value pairs.
8900        '''
8901
8902    def __repr__(self):
8903        return '<sdm.RawTCP ' + \
8904            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8905            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8906            'healthy: ' + repr(self.healthy) + ' ' +\
8907            'hostname: ' + repr(self.hostname) + ' ' +\
8908            'id: ' + repr(self.id) + ' ' +\
8909            'name: ' + repr(self.name) + ' ' +\
8910            'port: ' + repr(self.port) + ' ' +\
8911            'port_override: ' + repr(self.port_override) + ' ' +\
8912            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8913            'tags: ' + repr(self.tags) + ' ' +\
8914            '>'
8915
8916    def to_dict(self):
8917        return {
8918            'bind_interface': self.bind_interface,
8919            'egress_filter': self.egress_filter,
8920            'healthy': self.healthy,
8921            'hostname': self.hostname,
8922            'id': self.id,
8923            'name': self.name,
8924            'port': self.port,
8925            'port_override': self.port_override,
8926            'secret_store_id': self.secret_store_id,
8927            'tags': self.tags,
8928        }
8929
8930    @classmethod
8931    def from_dict(cls, d):
8932        return cls(
8933            bind_interface=d.get('bind_interface'),
8934            egress_filter=d.get('egress_filter'),
8935            healthy=d.get('healthy'),
8936            hostname=d.get('hostname'),
8937            id=d.get('id'),
8938            name=d.get('name'),
8939            port=d.get('port'),
8940            port_override=d.get('port_override'),
8941            secret_store_id=d.get('secret_store_id'),
8942            tags=d.get('tags'),
8943        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8857    def __init__(
8858        self,
8859        bind_interface=None,
8860        egress_filter=None,
8861        healthy=None,
8862        hostname=None,
8863        id=None,
8864        name=None,
8865        port=None,
8866        port_override=None,
8867        secret_store_id=None,
8868        tags=None,
8869    ):
8870        self.bind_interface = bind_interface if bind_interface is not None else ''
8871        '''
8872         Bind interface
8873        '''
8874        self.egress_filter = egress_filter if egress_filter is not None else ''
8875        '''
8876         A filter applied to the routing logic to pin datasource to nodes.
8877        '''
8878        self.healthy = healthy if healthy is not None else False
8879        '''
8880         True if the datasource is reachable and the credentials are valid.
8881        '''
8882        self.hostname = hostname if hostname is not None else ''
8883        self.id = id if id is not None else ''
8884        '''
8885         Unique identifier of the Resource.
8886        '''
8887        self.name = name if name is not None else ''
8888        '''
8889         Unique human-readable name of the Resource.
8890        '''
8891        self.port = port if port is not None else 0
8892        self.port_override = port_override if port_override is not None else 0
8893        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8894        '''
8895         ID of the secret store containing credentials for this resource, if any.
8896        '''
8897        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8898        '''
8899         Tags is a map of key, value pairs.
8900        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8916    def to_dict(self):
8917        return {
8918            'bind_interface': self.bind_interface,
8919            'egress_filter': self.egress_filter,
8920            'healthy': self.healthy,
8921            'hostname': self.hostname,
8922            'id': self.id,
8923            'name': self.name,
8924            'port': self.port,
8925            'port_override': self.port_override,
8926            'secret_store_id': self.secret_store_id,
8927            'tags': self.tags,
8928        }
@classmethod
def from_dict(cls, d)
8930    @classmethod
8931    def from_dict(cls, d):
8932        return cls(
8933            bind_interface=d.get('bind_interface'),
8934            egress_filter=d.get('egress_filter'),
8935            healthy=d.get('healthy'),
8936            hostname=d.get('hostname'),
8937            id=d.get('id'),
8938            name=d.get('name'),
8939            port=d.get('port'),
8940            port_override=d.get('port_override'),
8941            secret_store_id=d.get('secret_store_id'),
8942            tags=d.get('tags'),
8943        )
class Redis:
8946class Redis:
8947    __slots__ = [
8948        'bind_interface',
8949        'egress_filter',
8950        'healthy',
8951        'hostname',
8952        'id',
8953        'name',
8954        'password',
8955        'port',
8956        'port_override',
8957        'secret_store_id',
8958        'tags',
8959    ]
8960
8961    def __init__(
8962        self,
8963        bind_interface=None,
8964        egress_filter=None,
8965        healthy=None,
8966        hostname=None,
8967        id=None,
8968        name=None,
8969        password=None,
8970        port=None,
8971        port_override=None,
8972        secret_store_id=None,
8973        tags=None,
8974    ):
8975        self.bind_interface = bind_interface if bind_interface is not None else ''
8976        '''
8977         Bind interface
8978        '''
8979        self.egress_filter = egress_filter if egress_filter is not None else ''
8980        '''
8981         A filter applied to the routing logic to pin datasource to nodes.
8982        '''
8983        self.healthy = healthy if healthy is not None else False
8984        '''
8985         True if the datasource is reachable and the credentials are valid.
8986        '''
8987        self.hostname = hostname if hostname is not None else ''
8988        self.id = id if id is not None else ''
8989        '''
8990         Unique identifier of the Resource.
8991        '''
8992        self.name = name if name is not None else ''
8993        '''
8994         Unique human-readable name of the Resource.
8995        '''
8996        self.password = password if password is not None else ''
8997        self.port = port if port is not None else 0
8998        self.port_override = port_override if port_override is not None else 0
8999        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9000        '''
9001         ID of the secret store containing credentials for this resource, if any.
9002        '''
9003        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9004        '''
9005         Tags is a map of key, value pairs.
9006        '''
9007
9008    def __repr__(self):
9009        return '<sdm.Redis ' + \
9010            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9011            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9012            'healthy: ' + repr(self.healthy) + ' ' +\
9013            'hostname: ' + repr(self.hostname) + ' ' +\
9014            'id: ' + repr(self.id) + ' ' +\
9015            'name: ' + repr(self.name) + ' ' +\
9016            'password: ' + repr(self.password) + ' ' +\
9017            'port: ' + repr(self.port) + ' ' +\
9018            'port_override: ' + repr(self.port_override) + ' ' +\
9019            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9020            'tags: ' + repr(self.tags) + ' ' +\
9021            '>'
9022
9023    def to_dict(self):
9024        return {
9025            'bind_interface': self.bind_interface,
9026            'egress_filter': self.egress_filter,
9027            'healthy': self.healthy,
9028            'hostname': self.hostname,
9029            'id': self.id,
9030            'name': self.name,
9031            'password': self.password,
9032            'port': self.port,
9033            'port_override': self.port_override,
9034            'secret_store_id': self.secret_store_id,
9035            'tags': self.tags,
9036        }
9037
9038    @classmethod
9039    def from_dict(cls, d):
9040        return cls(
9041            bind_interface=d.get('bind_interface'),
9042            egress_filter=d.get('egress_filter'),
9043            healthy=d.get('healthy'),
9044            hostname=d.get('hostname'),
9045            id=d.get('id'),
9046            name=d.get('name'),
9047            password=d.get('password'),
9048            port=d.get('port'),
9049            port_override=d.get('port_override'),
9050            secret_store_id=d.get('secret_store_id'),
9051            tags=d.get('tags'),
9052        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None)
8961    def __init__(
8962        self,
8963        bind_interface=None,
8964        egress_filter=None,
8965        healthy=None,
8966        hostname=None,
8967        id=None,
8968        name=None,
8969        password=None,
8970        port=None,
8971        port_override=None,
8972        secret_store_id=None,
8973        tags=None,
8974    ):
8975        self.bind_interface = bind_interface if bind_interface is not None else ''
8976        '''
8977         Bind interface
8978        '''
8979        self.egress_filter = egress_filter if egress_filter is not None else ''
8980        '''
8981         A filter applied to the routing logic to pin datasource to nodes.
8982        '''
8983        self.healthy = healthy if healthy is not None else False
8984        '''
8985         True if the datasource is reachable and the credentials are valid.
8986        '''
8987        self.hostname = hostname if hostname is not None else ''
8988        self.id = id if id is not None else ''
8989        '''
8990         Unique identifier of the Resource.
8991        '''
8992        self.name = name if name is not None else ''
8993        '''
8994         Unique human-readable name of the Resource.
8995        '''
8996        self.password = password if password is not None else ''
8997        self.port = port if port is not None else 0
8998        self.port_override = port_override if port_override is not None else 0
8999        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9000        '''
9001         ID of the secret store containing credentials for this resource, if any.
9002        '''
9003        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9004        '''
9005         Tags is a map of key, value pairs.
9006        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9023    def to_dict(self):
9024        return {
9025            'bind_interface': self.bind_interface,
9026            'egress_filter': self.egress_filter,
9027            'healthy': self.healthy,
9028            'hostname': self.hostname,
9029            'id': self.id,
9030            'name': self.name,
9031            'password': self.password,
9032            'port': self.port,
9033            'port_override': self.port_override,
9034            'secret_store_id': self.secret_store_id,
9035            'tags': self.tags,
9036        }
@classmethod
def from_dict(cls, d)
9038    @classmethod
9039    def from_dict(cls, d):
9040        return cls(
9041            bind_interface=d.get('bind_interface'),
9042            egress_filter=d.get('egress_filter'),
9043            healthy=d.get('healthy'),
9044            hostname=d.get('hostname'),
9045            id=d.get('id'),
9046            name=d.get('name'),
9047            password=d.get('password'),
9048            port=d.get('port'),
9049            port_override=d.get('port_override'),
9050            secret_store_id=d.get('secret_store_id'),
9051            tags=d.get('tags'),
9052        )
class Redshift:
9055class Redshift:
9056    __slots__ = [
9057        'bind_interface',
9058        'database',
9059        'egress_filter',
9060        'healthy',
9061        'hostname',
9062        'id',
9063        'name',
9064        'override_database',
9065        'password',
9066        'port',
9067        'port_override',
9068        'secret_store_id',
9069        'tags',
9070        'username',
9071    ]
9072
9073    def __init__(
9074        self,
9075        bind_interface=None,
9076        database=None,
9077        egress_filter=None,
9078        healthy=None,
9079        hostname=None,
9080        id=None,
9081        name=None,
9082        override_database=None,
9083        password=None,
9084        port=None,
9085        port_override=None,
9086        secret_store_id=None,
9087        tags=None,
9088        username=None,
9089    ):
9090        self.bind_interface = bind_interface if bind_interface is not None else ''
9091        '''
9092         Bind interface
9093        '''
9094        self.database = database if database is not None else ''
9095        self.egress_filter = egress_filter if egress_filter is not None else ''
9096        '''
9097         A filter applied to the routing logic to pin datasource to nodes.
9098        '''
9099        self.healthy = healthy if healthy is not None else False
9100        '''
9101         True if the datasource is reachable and the credentials are valid.
9102        '''
9103        self.hostname = hostname if hostname is not None else ''
9104        self.id = id if id is not None else ''
9105        '''
9106         Unique identifier of the Resource.
9107        '''
9108        self.name = name if name is not None else ''
9109        '''
9110         Unique human-readable name of the Resource.
9111        '''
9112        self.override_database = override_database if override_database is not None else False
9113        self.password = password if password is not None else ''
9114        self.port = port if port is not None else 0
9115        self.port_override = port_override if port_override is not None else 0
9116        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9117        '''
9118         ID of the secret store containing credentials for this resource, if any.
9119        '''
9120        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9121        '''
9122         Tags is a map of key, value pairs.
9123        '''
9124        self.username = username if username is not None else ''
9125
9126    def __repr__(self):
9127        return '<sdm.Redshift ' + \
9128            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9129            'database: ' + repr(self.database) + ' ' +\
9130            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9131            'healthy: ' + repr(self.healthy) + ' ' +\
9132            'hostname: ' + repr(self.hostname) + ' ' +\
9133            'id: ' + repr(self.id) + ' ' +\
9134            'name: ' + repr(self.name) + ' ' +\
9135            'override_database: ' + repr(self.override_database) + ' ' +\
9136            'password: ' + repr(self.password) + ' ' +\
9137            'port: ' + repr(self.port) + ' ' +\
9138            'port_override: ' + repr(self.port_override) + ' ' +\
9139            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9140            'tags: ' + repr(self.tags) + ' ' +\
9141            'username: ' + repr(self.username) + ' ' +\
9142            '>'
9143
9144    def to_dict(self):
9145        return {
9146            'bind_interface': self.bind_interface,
9147            'database': self.database,
9148            'egress_filter': self.egress_filter,
9149            'healthy': self.healthy,
9150            'hostname': self.hostname,
9151            'id': self.id,
9152            'name': self.name,
9153            'override_database': self.override_database,
9154            'password': self.password,
9155            'port': self.port,
9156            'port_override': self.port_override,
9157            'secret_store_id': self.secret_store_id,
9158            'tags': self.tags,
9159            'username': self.username,
9160        }
9161
9162    @classmethod
9163    def from_dict(cls, d):
9164        return cls(
9165            bind_interface=d.get('bind_interface'),
9166            database=d.get('database'),
9167            egress_filter=d.get('egress_filter'),
9168            healthy=d.get('healthy'),
9169            hostname=d.get('hostname'),
9170            id=d.get('id'),
9171            name=d.get('name'),
9172            override_database=d.get('override_database'),
9173            password=d.get('password'),
9174            port=d.get('port'),
9175            port_override=d.get('port_override'),
9176            secret_store_id=d.get('secret_store_id'),
9177            tags=d.get('tags'),
9178            username=d.get('username'),
9179        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9073    def __init__(
9074        self,
9075        bind_interface=None,
9076        database=None,
9077        egress_filter=None,
9078        healthy=None,
9079        hostname=None,
9080        id=None,
9081        name=None,
9082        override_database=None,
9083        password=None,
9084        port=None,
9085        port_override=None,
9086        secret_store_id=None,
9087        tags=None,
9088        username=None,
9089    ):
9090        self.bind_interface = bind_interface if bind_interface is not None else ''
9091        '''
9092         Bind interface
9093        '''
9094        self.database = database if database is not None else ''
9095        self.egress_filter = egress_filter if egress_filter is not None else ''
9096        '''
9097         A filter applied to the routing logic to pin datasource to nodes.
9098        '''
9099        self.healthy = healthy if healthy is not None else False
9100        '''
9101         True if the datasource is reachable and the credentials are valid.
9102        '''
9103        self.hostname = hostname if hostname is not None else ''
9104        self.id = id if id is not None else ''
9105        '''
9106         Unique identifier of the Resource.
9107        '''
9108        self.name = name if name is not None else ''
9109        '''
9110         Unique human-readable name of the Resource.
9111        '''
9112        self.override_database = override_database if override_database is not None else False
9113        self.password = password if password is not None else ''
9114        self.port = port if port is not None else 0
9115        self.port_override = port_override if port_override is not None else 0
9116        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9117        '''
9118         ID of the secret store containing credentials for this resource, if any.
9119        '''
9120        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9121        '''
9122         Tags is a map of key, value pairs.
9123        '''
9124        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9144    def to_dict(self):
9145        return {
9146            'bind_interface': self.bind_interface,
9147            'database': self.database,
9148            'egress_filter': self.egress_filter,
9149            'healthy': self.healthy,
9150            'hostname': self.hostname,
9151            'id': self.id,
9152            'name': self.name,
9153            'override_database': self.override_database,
9154            'password': self.password,
9155            'port': self.port,
9156            'port_override': self.port_override,
9157            'secret_store_id': self.secret_store_id,
9158            'tags': self.tags,
9159            'username': self.username,
9160        }
@classmethod
def from_dict(cls, d)
9162    @classmethod
9163    def from_dict(cls, d):
9164        return cls(
9165            bind_interface=d.get('bind_interface'),
9166            database=d.get('database'),
9167            egress_filter=d.get('egress_filter'),
9168            healthy=d.get('healthy'),
9169            hostname=d.get('hostname'),
9170            id=d.get('id'),
9171            name=d.get('name'),
9172            override_database=d.get('override_database'),
9173            password=d.get('password'),
9174            port=d.get('port'),
9175            port_override=d.get('port_override'),
9176            secret_store_id=d.get('secret_store_id'),
9177            tags=d.get('tags'),
9178            username=d.get('username'),
9179        )
class Relay:
9182class Relay:
9183    '''
9184         Relay represents a StrongDM CLI installation running in relay mode.
9185    '''
9186    __slots__ = [
9187        'gateway_filter',
9188        'id',
9189        'name',
9190        'state',
9191        'tags',
9192    ]
9193
9194    def __init__(
9195        self,
9196        gateway_filter=None,
9197        id=None,
9198        name=None,
9199        state=None,
9200        tags=None,
9201    ):
9202        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9203        '''
9204         GatewayFilter can be used to restrict the peering between relays and
9205         gateways.
9206        '''
9207        self.id = id if id is not None else ''
9208        '''
9209         Unique identifier of the Relay.
9210        '''
9211        self.name = name if name is not None else ''
9212        '''
9213         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9214        '''
9215        self.state = state if state is not None else ''
9216        '''
9217         The current state of the relay. One of: "new", "verifying_restart",
9218         "awaiting_restart", "restarting", "started", "stopped", "dead",
9219         "unknown".
9220        '''
9221        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9222        '''
9223         Tags is a map of key, value pairs.
9224        '''
9225
9226    def __repr__(self):
9227        return '<sdm.Relay ' + \
9228            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
9229            'id: ' + repr(self.id) + ' ' +\
9230            'name: ' + repr(self.name) + ' ' +\
9231            'state: ' + repr(self.state) + ' ' +\
9232            'tags: ' + repr(self.tags) + ' ' +\
9233            '>'
9234
9235    def to_dict(self):
9236        return {
9237            'gateway_filter': self.gateway_filter,
9238            'id': self.id,
9239            'name': self.name,
9240            'state': self.state,
9241            'tags': self.tags,
9242        }
9243
9244    @classmethod
9245    def from_dict(cls, d):
9246        return cls(
9247            gateway_filter=d.get('gateway_filter'),
9248            id=d.get('id'),
9249            name=d.get('name'),
9250            state=d.get('state'),
9251            tags=d.get('tags'),
9252        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay(gateway_filter=None, id=None, name=None, state=None, tags=None)
9194    def __init__(
9195        self,
9196        gateway_filter=None,
9197        id=None,
9198        name=None,
9199        state=None,
9200        tags=None,
9201    ):
9202        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9203        '''
9204         GatewayFilter can be used to restrict the peering between relays and
9205         gateways.
9206        '''
9207        self.id = id if id is not None else ''
9208        '''
9209         Unique identifier of the Relay.
9210        '''
9211        self.name = name if name is not None else ''
9212        '''
9213         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9214        '''
9215        self.state = state if state is not None else ''
9216        '''
9217         The current state of the relay. One of: "new", "verifying_restart",
9218         "awaiting_restart", "restarting", "started", "stopped", "dead",
9219         "unknown".
9220        '''
9221        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9222        '''
9223         Tags is a map of key, value pairs.
9224        '''
gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

def to_dict(self)
9235    def to_dict(self):
9236        return {
9237            'gateway_filter': self.gateway_filter,
9238            'id': self.id,
9239            'name': self.name,
9240            'state': self.state,
9241            'tags': self.tags,
9242        }
@classmethod
def from_dict(cls, d)
9244    @classmethod
9245    def from_dict(cls, d):
9246        return cls(
9247            gateway_filter=d.get('gateway_filter'),
9248            id=d.get('id'),
9249            name=d.get('name'),
9250            state=d.get('state'),
9251            tags=d.get('tags'),
9252        )
class RemoteIdentity:
9255class RemoteIdentity:
9256    '''
9257         RemoteIdentities define the username to be used for a specific account
9258     when connecting to a remote resource using that group.
9259    '''
9260    __slots__ = [
9261        'account_id',
9262        'id',
9263        'remote_identity_group_id',
9264        'username',
9265    ]
9266
9267    def __init__(
9268        self,
9269        account_id=None,
9270        id=None,
9271        remote_identity_group_id=None,
9272        username=None,
9273    ):
9274        self.account_id = account_id if account_id is not None else ''
9275        '''
9276         The account for this remote identity.
9277        '''
9278        self.id = id if id is not None else ''
9279        '''
9280         Unique identifier of the RemoteIdentity.
9281        '''
9282        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9283        '''
9284         The remote identity group.
9285        '''
9286        self.username = username if username is not None else ''
9287        '''
9288         The username to be used as the remote identity for this account.
9289        '''
9290
9291    def __repr__(self):
9292        return '<sdm.RemoteIdentity ' + \
9293            'account_id: ' + repr(self.account_id) + ' ' +\
9294            'id: ' + repr(self.id) + ' ' +\
9295            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
9296            'username: ' + repr(self.username) + ' ' +\
9297            '>'
9298
9299    def to_dict(self):
9300        return {
9301            'account_id': self.account_id,
9302            'id': self.id,
9303            'remote_identity_group_id': self.remote_identity_group_id,
9304            'username': self.username,
9305        }
9306
9307    @classmethod
9308    def from_dict(cls, d):
9309        return cls(
9310            account_id=d.get('account_id'),
9311            id=d.get('id'),
9312            remote_identity_group_id=d.get('remote_identity_group_id'),
9313            username=d.get('username'),
9314        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
9267    def __init__(
9268        self,
9269        account_id=None,
9270        id=None,
9271        remote_identity_group_id=None,
9272        username=None,
9273    ):
9274        self.account_id = account_id if account_id is not None else ''
9275        '''
9276         The account for this remote identity.
9277        '''
9278        self.id = id if id is not None else ''
9279        '''
9280         Unique identifier of the RemoteIdentity.
9281        '''
9282        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9283        '''
9284         The remote identity group.
9285        '''
9286        self.username = username if username is not None else ''
9287        '''
9288         The username to be used as the remote identity for this account.
9289        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
9299    def to_dict(self):
9300        return {
9301            'account_id': self.account_id,
9302            'id': self.id,
9303            'remote_identity_group_id': self.remote_identity_group_id,
9304            'username': self.username,
9305        }
@classmethod
def from_dict(cls, d)
9307    @classmethod
9308    def from_dict(cls, d):
9309        return cls(
9310            account_id=d.get('account_id'),
9311            id=d.get('id'),
9312            remote_identity_group_id=d.get('remote_identity_group_id'),
9313            username=d.get('username'),
9314        )
class RemoteIdentityCreateResponse:
9317class RemoteIdentityCreateResponse:
9318    '''
9319         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
9320    '''
9321    __slots__ = [
9322        'meta',
9323        'rate_limit',
9324        'remote_identity',
9325    ]
9326
9327    def __init__(
9328        self,
9329        meta=None,
9330        rate_limit=None,
9331        remote_identity=None,
9332    ):
9333        self.meta = meta if meta is not None else None
9334        '''
9335         Reserved for future use.
9336        '''
9337        self.rate_limit = rate_limit if rate_limit is not None else None
9338        '''
9339         Rate limit information.
9340        '''
9341        self.remote_identity = remote_identity if remote_identity is not None else None
9342        '''
9343         The created RemoteIdentity.
9344        '''
9345
9346    def __repr__(self):
9347        return '<sdm.RemoteIdentityCreateResponse ' + \
9348            'meta: ' + repr(self.meta) + ' ' +\
9349            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9350            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9351            '>'
9352
9353    def to_dict(self):
9354        return {
9355            'meta': self.meta,
9356            'rate_limit': self.rate_limit,
9357            'remote_identity': self.remote_identity,
9358        }
9359
9360    @classmethod
9361    def from_dict(cls, d):
9362        return cls(
9363            meta=d.get('meta'),
9364            rate_limit=d.get('rate_limit'),
9365            remote_identity=d.get('remote_identity'),
9366        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
9327    def __init__(
9328        self,
9329        meta=None,
9330        rate_limit=None,
9331        remote_identity=None,
9332    ):
9333        self.meta = meta if meta is not None else None
9334        '''
9335         Reserved for future use.
9336        '''
9337        self.rate_limit = rate_limit if rate_limit is not None else None
9338        '''
9339         Rate limit information.
9340        '''
9341        self.remote_identity = remote_identity if remote_identity is not None else None
9342        '''
9343         The created RemoteIdentity.
9344        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
9353    def to_dict(self):
9354        return {
9355            'meta': self.meta,
9356            'rate_limit': self.rate_limit,
9357            'remote_identity': self.remote_identity,
9358        }
@classmethod
def from_dict(cls, d)
9360    @classmethod
9361    def from_dict(cls, d):
9362        return cls(
9363            meta=d.get('meta'),
9364            rate_limit=d.get('rate_limit'),
9365            remote_identity=d.get('remote_identity'),
9366        )
class RemoteIdentityDeleteResponse:
9369class RemoteIdentityDeleteResponse:
9370    '''
9371         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
9372    '''
9373    __slots__ = [
9374        'meta',
9375        'rate_limit',
9376    ]
9377
9378    def __init__(
9379        self,
9380        meta=None,
9381        rate_limit=None,
9382    ):
9383        self.meta = meta if meta is not None else None
9384        '''
9385         Reserved for future use.
9386        '''
9387        self.rate_limit = rate_limit if rate_limit is not None else None
9388        '''
9389         Rate limit information.
9390        '''
9391
9392    def __repr__(self):
9393        return '<sdm.RemoteIdentityDeleteResponse ' + \
9394            'meta: ' + repr(self.meta) + ' ' +\
9395            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9396            '>'
9397
9398    def to_dict(self):
9399        return {
9400            'meta': self.meta,
9401            'rate_limit': self.rate_limit,
9402        }
9403
9404    @classmethod
9405    def from_dict(cls, d):
9406        return cls(
9407            meta=d.get('meta'),
9408            rate_limit=d.get('rate_limit'),
9409        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
9378    def __init__(
9379        self,
9380        meta=None,
9381        rate_limit=None,
9382    ):
9383        self.meta = meta if meta is not None else None
9384        '''
9385         Reserved for future use.
9386        '''
9387        self.rate_limit = rate_limit if rate_limit is not None else None
9388        '''
9389         Rate limit information.
9390        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9398    def to_dict(self):
9399        return {
9400            'meta': self.meta,
9401            'rate_limit': self.rate_limit,
9402        }
@classmethod
def from_dict(cls, d)
9404    @classmethod
9405    def from_dict(cls, d):
9406        return cls(
9407            meta=d.get('meta'),
9408            rate_limit=d.get('rate_limit'),
9409        )
class RemoteIdentityGetResponse:
9412class RemoteIdentityGetResponse:
9413    '''
9414         RemoteIdentityGetResponse returns a requested RemoteIdentity.
9415    '''
9416    __slots__ = [
9417        'meta',
9418        'rate_limit',
9419        'remote_identity',
9420    ]
9421
9422    def __init__(
9423        self,
9424        meta=None,
9425        rate_limit=None,
9426        remote_identity=None,
9427    ):
9428        self.meta = meta if meta is not None else None
9429        '''
9430         Reserved for future use.
9431        '''
9432        self.rate_limit = rate_limit if rate_limit is not None else None
9433        '''
9434         Rate limit information.
9435        '''
9436        self.remote_identity = remote_identity if remote_identity is not None else None
9437        '''
9438         The requested RemoteIdentity.
9439        '''
9440
9441    def __repr__(self):
9442        return '<sdm.RemoteIdentityGetResponse ' + \
9443            'meta: ' + repr(self.meta) + ' ' +\
9444            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9445            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9446            '>'
9447
9448    def to_dict(self):
9449        return {
9450            'meta': self.meta,
9451            'rate_limit': self.rate_limit,
9452            'remote_identity': self.remote_identity,
9453        }
9454
9455    @classmethod
9456    def from_dict(cls, d):
9457        return cls(
9458            meta=d.get('meta'),
9459            rate_limit=d.get('rate_limit'),
9460            remote_identity=d.get('remote_identity'),
9461        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
9422    def __init__(
9423        self,
9424        meta=None,
9425        rate_limit=None,
9426        remote_identity=None,
9427    ):
9428        self.meta = meta if meta is not None else None
9429        '''
9430         Reserved for future use.
9431        '''
9432        self.rate_limit = rate_limit if rate_limit is not None else None
9433        '''
9434         Rate limit information.
9435        '''
9436        self.remote_identity = remote_identity if remote_identity is not None else None
9437        '''
9438         The requested RemoteIdentity.
9439        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
9448    def to_dict(self):
9449        return {
9450            'meta': self.meta,
9451            'rate_limit': self.rate_limit,
9452            'remote_identity': self.remote_identity,
9453        }
@classmethod
def from_dict(cls, d)
9455    @classmethod
9456    def from_dict(cls, d):
9457        return cls(
9458            meta=d.get('meta'),
9459            rate_limit=d.get('rate_limit'),
9460            remote_identity=d.get('remote_identity'),
9461        )
class RemoteIdentityGroup:
9464class RemoteIdentityGroup:
9465    '''
9466         A RemoteIdentityGroup defines a group of remote identities.
9467    '''
9468    __slots__ = [
9469        'id',
9470        'name',
9471    ]
9472
9473    def __init__(
9474        self,
9475        id=None,
9476        name=None,
9477    ):
9478        self.id = id if id is not None else ''
9479        '''
9480         Unique identifier of the RemoteIdentityGroup.
9481        '''
9482        self.name = name if name is not None else ''
9483        '''
9484         Unique human-readable name of the RemoteIdentityGroup.
9485        '''
9486
9487    def __repr__(self):
9488        return '<sdm.RemoteIdentityGroup ' + \
9489            'id: ' + repr(self.id) + ' ' +\
9490            'name: ' + repr(self.name) + ' ' +\
9491            '>'
9492
9493    def to_dict(self):
9494        return {
9495            'id': self.id,
9496            'name': self.name,
9497        }
9498
9499    @classmethod
9500    def from_dict(cls, d):
9501        return cls(
9502            id=d.get('id'),
9503            name=d.get('name'),
9504        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
9473    def __init__(
9474        self,
9475        id=None,
9476        name=None,
9477    ):
9478        self.id = id if id is not None else ''
9479        '''
9480         Unique identifier of the RemoteIdentityGroup.
9481        '''
9482        self.name = name if name is not None else ''
9483        '''
9484         Unique human-readable name of the RemoteIdentityGroup.
9485        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
9493    def to_dict(self):
9494        return {
9495            'id': self.id,
9496            'name': self.name,
9497        }
@classmethod
def from_dict(cls, d)
9499    @classmethod
9500    def from_dict(cls, d):
9501        return cls(
9502            id=d.get('id'),
9503            name=d.get('name'),
9504        )
class RemoteIdentityGroupGetResponse:
9507class RemoteIdentityGroupGetResponse:
9508    '''
9509         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
9510    '''
9511    __slots__ = [
9512        'meta',
9513        'rate_limit',
9514        'remote_identity_group',
9515    ]
9516
9517    def __init__(
9518        self,
9519        meta=None,
9520        rate_limit=None,
9521        remote_identity_group=None,
9522    ):
9523        self.meta = meta if meta is not None else None
9524        '''
9525         Reserved for future use.
9526        '''
9527        self.rate_limit = rate_limit if rate_limit is not None else None
9528        '''
9529         Rate limit information.
9530        '''
9531        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
9532        '''
9533         The requested RemoteIdentityGroup.
9534        '''
9535
9536    def __repr__(self):
9537        return '<sdm.RemoteIdentityGroupGetResponse ' + \
9538            'meta: ' + repr(self.meta) + ' ' +\
9539            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9540            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
9541            '>'
9542
9543    def to_dict(self):
9544        return {
9545            'meta': self.meta,
9546            'rate_limit': self.rate_limit,
9547            'remote_identity_group': self.remote_identity_group,
9548        }
9549
9550    @classmethod
9551    def from_dict(cls, d):
9552        return cls(
9553            meta=d.get('meta'),
9554            rate_limit=d.get('rate_limit'),
9555            remote_identity_group=d.get('remote_identity_group'),
9556        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
9517    def __init__(
9518        self,
9519        meta=None,
9520        rate_limit=None,
9521        remote_identity_group=None,
9522    ):
9523        self.meta = meta if meta is not None else None
9524        '''
9525         Reserved for future use.
9526        '''
9527        self.rate_limit = rate_limit if rate_limit is not None else None
9528        '''
9529         Rate limit information.
9530        '''
9531        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
9532        '''
9533         The requested RemoteIdentityGroup.
9534        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
9543    def to_dict(self):
9544        return {
9545            'meta': self.meta,
9546            'rate_limit': self.rate_limit,
9547            'remote_identity_group': self.remote_identity_group,
9548        }
@classmethod
def from_dict(cls, d)
9550    @classmethod
9551    def from_dict(cls, d):
9552        return cls(
9553            meta=d.get('meta'),
9554            rate_limit=d.get('rate_limit'),
9555            remote_identity_group=d.get('remote_identity_group'),
9556        )
class RemoteIdentityUpdateResponse:
9559class RemoteIdentityUpdateResponse:
9560    '''
9561         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
9562     a RemoteIdentityUpdateRequest.
9563    '''
9564    __slots__ = [
9565        'meta',
9566        'rate_limit',
9567        'remote_identity',
9568    ]
9569
9570    def __init__(
9571        self,
9572        meta=None,
9573        rate_limit=None,
9574        remote_identity=None,
9575    ):
9576        self.meta = meta if meta is not None else None
9577        '''
9578         Reserved for future use.
9579        '''
9580        self.rate_limit = rate_limit if rate_limit is not None else None
9581        '''
9582         Rate limit information.
9583        '''
9584        self.remote_identity = remote_identity if remote_identity is not None else None
9585        '''
9586         The updated RemoteIdentity.
9587        '''
9588
9589    def __repr__(self):
9590        return '<sdm.RemoteIdentityUpdateResponse ' + \
9591            'meta: ' + repr(self.meta) + ' ' +\
9592            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9593            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9594            '>'
9595
9596    def to_dict(self):
9597        return {
9598            'meta': self.meta,
9599            'rate_limit': self.rate_limit,
9600            'remote_identity': self.remote_identity,
9601        }
9602
9603    @classmethod
9604    def from_dict(cls, d):
9605        return cls(
9606            meta=d.get('meta'),
9607            rate_limit=d.get('rate_limit'),
9608            remote_identity=d.get('remote_identity'),
9609        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
9570    def __init__(
9571        self,
9572        meta=None,
9573        rate_limit=None,
9574        remote_identity=None,
9575    ):
9576        self.meta = meta if meta is not None else None
9577        '''
9578         Reserved for future use.
9579        '''
9580        self.rate_limit = rate_limit if rate_limit is not None else None
9581        '''
9582         Rate limit information.
9583        '''
9584        self.remote_identity = remote_identity if remote_identity is not None else None
9585        '''
9586         The updated RemoteIdentity.
9587        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
9596    def to_dict(self):
9597        return {
9598            'meta': self.meta,
9599            'rate_limit': self.rate_limit,
9600            'remote_identity': self.remote_identity,
9601        }
@classmethod
def from_dict(cls, d)
9603    @classmethod
9604    def from_dict(cls, d):
9605        return cls(
9606            meta=d.get('meta'),
9607            rate_limit=d.get('rate_limit'),
9608            remote_identity=d.get('remote_identity'),
9609        )
class ResourceCreateResponse:
9612class ResourceCreateResponse:
9613    '''
9614         ResourceCreateResponse reports how the Resources were created in the system.
9615    '''
9616    __slots__ = [
9617        'meta',
9618        'rate_limit',
9619        'resource',
9620    ]
9621
9622    def __init__(
9623        self,
9624        meta=None,
9625        rate_limit=None,
9626        resource=None,
9627    ):
9628        self.meta = meta if meta is not None else None
9629        '''
9630         Reserved for future use.
9631        '''
9632        self.rate_limit = rate_limit if rate_limit is not None else None
9633        '''
9634         Rate limit information.
9635        '''
9636        self.resource = resource if resource is not None else None
9637        '''
9638         The created Resource.
9639        '''
9640
9641    def __repr__(self):
9642        return '<sdm.ResourceCreateResponse ' + \
9643            'meta: ' + repr(self.meta) + ' ' +\
9644            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9645            'resource: ' + repr(self.resource) + ' ' +\
9646            '>'
9647
9648    def to_dict(self):
9649        return {
9650            'meta': self.meta,
9651            'rate_limit': self.rate_limit,
9652            'resource': self.resource,
9653        }
9654
9655    @classmethod
9656    def from_dict(cls, d):
9657        return cls(
9658            meta=d.get('meta'),
9659            rate_limit=d.get('rate_limit'),
9660            resource=d.get('resource'),
9661        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
9622    def __init__(
9623        self,
9624        meta=None,
9625        rate_limit=None,
9626        resource=None,
9627    ):
9628        self.meta = meta if meta is not None else None
9629        '''
9630         Reserved for future use.
9631        '''
9632        self.rate_limit = rate_limit if rate_limit is not None else None
9633        '''
9634         Rate limit information.
9635        '''
9636        self.resource = resource if resource is not None else None
9637        '''
9638         The created Resource.
9639        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
9648    def to_dict(self):
9649        return {
9650            'meta': self.meta,
9651            'rate_limit': self.rate_limit,
9652            'resource': self.resource,
9653        }
@classmethod
def from_dict(cls, d)
9655    @classmethod
9656    def from_dict(cls, d):
9657        return cls(
9658            meta=d.get('meta'),
9659            rate_limit=d.get('rate_limit'),
9660            resource=d.get('resource'),
9661        )
class ResourceDeleteResponse:
9664class ResourceDeleteResponse:
9665    '''
9666         ResourceDeleteResponse returns information about a Resource that was deleted.
9667    '''
9668    __slots__ = [
9669        'meta',
9670        'rate_limit',
9671    ]
9672
9673    def __init__(
9674        self,
9675        meta=None,
9676        rate_limit=None,
9677    ):
9678        self.meta = meta if meta is not None else None
9679        '''
9680         Reserved for future use.
9681        '''
9682        self.rate_limit = rate_limit if rate_limit is not None else None
9683        '''
9684         Rate limit information.
9685        '''
9686
9687    def __repr__(self):
9688        return '<sdm.ResourceDeleteResponse ' + \
9689            'meta: ' + repr(self.meta) + ' ' +\
9690            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9691            '>'
9692
9693    def to_dict(self):
9694        return {
9695            'meta': self.meta,
9696            'rate_limit': self.rate_limit,
9697        }
9698
9699    @classmethod
9700    def from_dict(cls, d):
9701        return cls(
9702            meta=d.get('meta'),
9703            rate_limit=d.get('rate_limit'),
9704        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
9673    def __init__(
9674        self,
9675        meta=None,
9676        rate_limit=None,
9677    ):
9678        self.meta = meta if meta is not None else None
9679        '''
9680         Reserved for future use.
9681        '''
9682        self.rate_limit = rate_limit if rate_limit is not None else None
9683        '''
9684         Rate limit information.
9685        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9693    def to_dict(self):
9694        return {
9695            'meta': self.meta,
9696            'rate_limit': self.rate_limit,
9697        }
@classmethod
def from_dict(cls, d)
9699    @classmethod
9700    def from_dict(cls, d):
9701        return cls(
9702            meta=d.get('meta'),
9703            rate_limit=d.get('rate_limit'),
9704        )
class ResourceGetResponse:
9707class ResourceGetResponse:
9708    '''
9709         ResourceGetResponse returns a requested Resource.
9710    '''
9711    __slots__ = [
9712        'meta',
9713        'rate_limit',
9714        'resource',
9715    ]
9716
9717    def __init__(
9718        self,
9719        meta=None,
9720        rate_limit=None,
9721        resource=None,
9722    ):
9723        self.meta = meta if meta is not None else None
9724        '''
9725         Reserved for future use.
9726        '''
9727        self.rate_limit = rate_limit if rate_limit is not None else None
9728        '''
9729         Rate limit information.
9730        '''
9731        self.resource = resource if resource is not None else None
9732        '''
9733         The requested Resource.
9734        '''
9735
9736    def __repr__(self):
9737        return '<sdm.ResourceGetResponse ' + \
9738            'meta: ' + repr(self.meta) + ' ' +\
9739            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9740            'resource: ' + repr(self.resource) + ' ' +\
9741            '>'
9742
9743    def to_dict(self):
9744        return {
9745            'meta': self.meta,
9746            'rate_limit': self.rate_limit,
9747            'resource': self.resource,
9748        }
9749
9750    @classmethod
9751    def from_dict(cls, d):
9752        return cls(
9753            meta=d.get('meta'),
9754            rate_limit=d.get('rate_limit'),
9755            resource=d.get('resource'),
9756        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
9717    def __init__(
9718        self,
9719        meta=None,
9720        rate_limit=None,
9721        resource=None,
9722    ):
9723        self.meta = meta if meta is not None else None
9724        '''
9725         Reserved for future use.
9726        '''
9727        self.rate_limit = rate_limit if rate_limit is not None else None
9728        '''
9729         Rate limit information.
9730        '''
9731        self.resource = resource if resource is not None else None
9732        '''
9733         The requested Resource.
9734        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
9743    def to_dict(self):
9744        return {
9745            'meta': self.meta,
9746            'rate_limit': self.rate_limit,
9747            'resource': self.resource,
9748        }
@classmethod
def from_dict(cls, d)
9750    @classmethod
9751    def from_dict(cls, d):
9752        return cls(
9753            meta=d.get('meta'),
9754            rate_limit=d.get('rate_limit'),
9755            resource=d.get('resource'),
9756        )
class ResourceUpdateResponse:
9759class ResourceUpdateResponse:
9760    '''
9761         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
9762     a ResourceUpdateRequest.
9763    '''
9764    __slots__ = [
9765        'meta',
9766        'rate_limit',
9767        'resource',
9768    ]
9769
9770    def __init__(
9771        self,
9772        meta=None,
9773        rate_limit=None,
9774        resource=None,
9775    ):
9776        self.meta = meta if meta is not None else None
9777        '''
9778         Reserved for future use.
9779        '''
9780        self.rate_limit = rate_limit if rate_limit is not None else None
9781        '''
9782         Rate limit information.
9783        '''
9784        self.resource = resource if resource is not None else None
9785        '''
9786         The updated Resource.
9787        '''
9788
9789    def __repr__(self):
9790        return '<sdm.ResourceUpdateResponse ' + \
9791            'meta: ' + repr(self.meta) + ' ' +\
9792            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9793            'resource: ' + repr(self.resource) + ' ' +\
9794            '>'
9795
9796    def to_dict(self):
9797        return {
9798            'meta': self.meta,
9799            'rate_limit': self.rate_limit,
9800            'resource': self.resource,
9801        }
9802
9803    @classmethod
9804    def from_dict(cls, d):
9805        return cls(
9806            meta=d.get('meta'),
9807            rate_limit=d.get('rate_limit'),
9808            resource=d.get('resource'),
9809        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
9770    def __init__(
9771        self,
9772        meta=None,
9773        rate_limit=None,
9774        resource=None,
9775    ):
9776        self.meta = meta if meta is not None else None
9777        '''
9778         Reserved for future use.
9779        '''
9780        self.rate_limit = rate_limit if rate_limit is not None else None
9781        '''
9782         Rate limit information.
9783        '''
9784        self.resource = resource if resource is not None else None
9785        '''
9786         The updated Resource.
9787        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
9796    def to_dict(self):
9797        return {
9798            'meta': self.meta,
9799            'rate_limit': self.rate_limit,
9800            'resource': self.resource,
9801        }
@classmethod
def from_dict(cls, d)
9803    @classmethod
9804    def from_dict(cls, d):
9805        return cls(
9806            meta=d.get('meta'),
9807            rate_limit=d.get('rate_limit'),
9808            resource=d.get('resource'),
9809        )
class Role:
9812class Role:
9813    '''
9814         A Role has a list of access rules which determine which Resources the members
9815     of the Role have access to. An Account can be a member of multiple Roles via
9816     AccountAttachments.
9817    '''
9818    __slots__ = [
9819        'access_rules',
9820        'id',
9821        'name',
9822        'tags',
9823    ]
9824
9825    def __init__(
9826        self,
9827        access_rules=None,
9828        id=None,
9829        name=None,
9830        tags=None,
9831    ):
9832        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
9833        )
9834        '''
9835         AccessRules is a list of access rules defining the resources this Role has access to.
9836        '''
9837        self.id = id if id is not None else ''
9838        '''
9839         Unique identifier of the Role.
9840        '''
9841        self.name = name if name is not None else ''
9842        '''
9843         Unique human-readable name of the Role.
9844        '''
9845        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9846        '''
9847         Tags is a map of key, value pairs.
9848        '''
9849
9850    def __repr__(self):
9851        return '<sdm.Role ' + \
9852            'access_rules: ' + repr(self.access_rules) + ' ' +\
9853            'id: ' + repr(self.id) + ' ' +\
9854            'name: ' + repr(self.name) + ' ' +\
9855            'tags: ' + repr(self.tags) + ' ' +\
9856            '>'
9857
9858    def to_dict(self):
9859        return {
9860            'access_rules': self.access_rules,
9861            'id': self.id,
9862            'name': self.name,
9863            'tags': self.tags,
9864        }
9865
9866    @classmethod
9867    def from_dict(cls, d):
9868        return cls(
9869            access_rules=d.get('access_rules'),
9870            id=d.get('id'),
9871            name=d.get('name'),
9872            tags=d.get('tags'),
9873        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, id=None, name=None, tags=None)
9825    def __init__(
9826        self,
9827        access_rules=None,
9828        id=None,
9829        name=None,
9830        tags=None,
9831    ):
9832        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
9833        )
9834        '''
9835         AccessRules is a list of access rules defining the resources this Role has access to.
9836        '''
9837        self.id = id if id is not None else ''
9838        '''
9839         Unique identifier of the Role.
9840        '''
9841        self.name = name if name is not None else ''
9842        '''
9843         Unique human-readable name of the Role.
9844        '''
9845        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9846        '''
9847         Tags is a map of key, value pairs.
9848        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

id

Unique identifier of the Role.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9858    def to_dict(self):
9859        return {
9860            'access_rules': self.access_rules,
9861            'id': self.id,
9862            'name': self.name,
9863            'tags': self.tags,
9864        }
@classmethod
def from_dict(cls, d)
9866    @classmethod
9867    def from_dict(cls, d):
9868        return cls(
9869            access_rules=d.get('access_rules'),
9870            id=d.get('id'),
9871            name=d.get('name'),
9872            tags=d.get('tags'),
9873        )
class RoleCreateResponse:
9876class RoleCreateResponse:
9877    '''
9878         RoleCreateResponse reports how the Roles were created in the system. It can
9879     communicate partial successes or failures.
9880    '''
9881    __slots__ = [
9882        'meta',
9883        'rate_limit',
9884        'role',
9885    ]
9886
9887    def __init__(
9888        self,
9889        meta=None,
9890        rate_limit=None,
9891        role=None,
9892    ):
9893        self.meta = meta if meta is not None else None
9894        '''
9895         Reserved for future use.
9896        '''
9897        self.rate_limit = rate_limit if rate_limit is not None else None
9898        '''
9899         Rate limit information.
9900        '''
9901        self.role = role if role is not None else None
9902        '''
9903         The created Role.
9904        '''
9905
9906    def __repr__(self):
9907        return '<sdm.RoleCreateResponse ' + \
9908            'meta: ' + repr(self.meta) + ' ' +\
9909            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9910            'role: ' + repr(self.role) + ' ' +\
9911            '>'
9912
9913    def to_dict(self):
9914        return {
9915            'meta': self.meta,
9916            'rate_limit': self.rate_limit,
9917            'role': self.role,
9918        }
9919
9920    @classmethod
9921    def from_dict(cls, d):
9922        return cls(
9923            meta=d.get('meta'),
9924            rate_limit=d.get('rate_limit'),
9925            role=d.get('role'),
9926        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
9887    def __init__(
9888        self,
9889        meta=None,
9890        rate_limit=None,
9891        role=None,
9892    ):
9893        self.meta = meta if meta is not None else None
9894        '''
9895         Reserved for future use.
9896        '''
9897        self.rate_limit = rate_limit if rate_limit is not None else None
9898        '''
9899         Rate limit information.
9900        '''
9901        self.role = role if role is not None else None
9902        '''
9903         The created Role.
9904        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
9913    def to_dict(self):
9914        return {
9915            'meta': self.meta,
9916            'rate_limit': self.rate_limit,
9917            'role': self.role,
9918        }
@classmethod
def from_dict(cls, d)
9920    @classmethod
9921    def from_dict(cls, d):
9922        return cls(
9923            meta=d.get('meta'),
9924            rate_limit=d.get('rate_limit'),
9925            role=d.get('role'),
9926        )
class RoleDeleteResponse:
9929class RoleDeleteResponse:
9930    '''
9931         RoleDeleteResponse returns information about a Role that was deleted.
9932    '''
9933    __slots__ = [
9934        'meta',
9935        'rate_limit',
9936    ]
9937
9938    def __init__(
9939        self,
9940        meta=None,
9941        rate_limit=None,
9942    ):
9943        self.meta = meta if meta is not None else None
9944        '''
9945         Reserved for future use.
9946        '''
9947        self.rate_limit = rate_limit if rate_limit is not None else None
9948        '''
9949         Rate limit information.
9950        '''
9951
9952    def __repr__(self):
9953        return '<sdm.RoleDeleteResponse ' + \
9954            'meta: ' + repr(self.meta) + ' ' +\
9955            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9956            '>'
9957
9958    def to_dict(self):
9959        return {
9960            'meta': self.meta,
9961            'rate_limit': self.rate_limit,
9962        }
9963
9964    @classmethod
9965    def from_dict(cls, d):
9966        return cls(
9967            meta=d.get('meta'),
9968            rate_limit=d.get('rate_limit'),
9969        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
9938    def __init__(
9939        self,
9940        meta=None,
9941        rate_limit=None,
9942    ):
9943        self.meta = meta if meta is not None else None
9944        '''
9945         Reserved for future use.
9946        '''
9947        self.rate_limit = rate_limit if rate_limit is not None else None
9948        '''
9949         Rate limit information.
9950        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9958    def to_dict(self):
9959        return {
9960            'meta': self.meta,
9961            'rate_limit': self.rate_limit,
9962        }
@classmethod
def from_dict(cls, d)
9964    @classmethod
9965    def from_dict(cls, d):
9966        return cls(
9967            meta=d.get('meta'),
9968            rate_limit=d.get('rate_limit'),
9969        )
class RoleGetResponse:
 9972class RoleGetResponse:
 9973    '''
 9974         RoleGetResponse returns a requested Role.
 9975    '''
 9976    __slots__ = [
 9977        'meta',
 9978        'rate_limit',
 9979        'role',
 9980    ]
 9981
 9982    def __init__(
 9983        self,
 9984        meta=None,
 9985        rate_limit=None,
 9986        role=None,
 9987    ):
 9988        self.meta = meta if meta is not None else None
 9989        '''
 9990         Reserved for future use.
 9991        '''
 9992        self.rate_limit = rate_limit if rate_limit is not None else None
 9993        '''
 9994         Rate limit information.
 9995        '''
 9996        self.role = role if role is not None else None
 9997        '''
 9998         The requested Role.
 9999        '''
10000
10001    def __repr__(self):
10002        return '<sdm.RoleGetResponse ' + \
10003            'meta: ' + repr(self.meta) + ' ' +\
10004            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10005            'role: ' + repr(self.role) + ' ' +\
10006            '>'
10007
10008    def to_dict(self):
10009        return {
10010            'meta': self.meta,
10011            'rate_limit': self.rate_limit,
10012            'role': self.role,
10013        }
10014
10015    @classmethod
10016    def from_dict(cls, d):
10017        return cls(
10018            meta=d.get('meta'),
10019            rate_limit=d.get('rate_limit'),
10020            role=d.get('role'),
10021        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
9982    def __init__(
9983        self,
9984        meta=None,
9985        rate_limit=None,
9986        role=None,
9987    ):
9988        self.meta = meta if meta is not None else None
9989        '''
9990         Reserved for future use.
9991        '''
9992        self.rate_limit = rate_limit if rate_limit is not None else None
9993        '''
9994         Rate limit information.
9995        '''
9996        self.role = role if role is not None else None
9997        '''
9998         The requested Role.
9999        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
10008    def to_dict(self):
10009        return {
10010            'meta': self.meta,
10011            'rate_limit': self.rate_limit,
10012            'role': self.role,
10013        }
@classmethod
def from_dict(cls, d)
10015    @classmethod
10016    def from_dict(cls, d):
10017        return cls(
10018            meta=d.get('meta'),
10019            rate_limit=d.get('rate_limit'),
10020            role=d.get('role'),
10021        )
class RoleUpdateResponse:
10024class RoleUpdateResponse:
10025    '''
10026         RoleUpdateResponse returns the fields of a Role after it has been updated by
10027     a RoleUpdateRequest.
10028    '''
10029    __slots__ = [
10030        'meta',
10031        'rate_limit',
10032        'role',
10033    ]
10034
10035    def __init__(
10036        self,
10037        meta=None,
10038        rate_limit=None,
10039        role=None,
10040    ):
10041        self.meta = meta if meta is not None else None
10042        '''
10043         Reserved for future use.
10044        '''
10045        self.rate_limit = rate_limit if rate_limit is not None else None
10046        '''
10047         Rate limit information.
10048        '''
10049        self.role = role if role is not None else None
10050        '''
10051         The updated Role.
10052        '''
10053
10054    def __repr__(self):
10055        return '<sdm.RoleUpdateResponse ' + \
10056            'meta: ' + repr(self.meta) + ' ' +\
10057            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10058            'role: ' + repr(self.role) + ' ' +\
10059            '>'
10060
10061    def to_dict(self):
10062        return {
10063            'meta': self.meta,
10064            'rate_limit': self.rate_limit,
10065            'role': self.role,
10066        }
10067
10068    @classmethod
10069    def from_dict(cls, d):
10070        return cls(
10071            meta=d.get('meta'),
10072            rate_limit=d.get('rate_limit'),
10073            role=d.get('role'),
10074        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
10035    def __init__(
10036        self,
10037        meta=None,
10038        rate_limit=None,
10039        role=None,
10040    ):
10041        self.meta = meta if meta is not None else None
10042        '''
10043         Reserved for future use.
10044        '''
10045        self.rate_limit = rate_limit if rate_limit is not None else None
10046        '''
10047         Rate limit information.
10048        '''
10049        self.role = role if role is not None else None
10050        '''
10051         The updated Role.
10052        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
10061    def to_dict(self):
10062        return {
10063            'meta': self.meta,
10064            'rate_limit': self.rate_limit,
10065            'role': self.role,
10066        }
@classmethod
def from_dict(cls, d)
10068    @classmethod
10069    def from_dict(cls, d):
10070        return cls(
10071            meta=d.get('meta'),
10072            rate_limit=d.get('rate_limit'),
10073            role=d.get('role'),
10074        )
class SQLServer:
10077class SQLServer:
10078    __slots__ = [
10079        'bind_interface',
10080        'database',
10081        'egress_filter',
10082        'healthy',
10083        'hostname',
10084        'id',
10085        'name',
10086        'override_database',
10087        'password',
10088        'port',
10089        'port_override',
10090        'schema',
10091        'secret_store_id',
10092        'tags',
10093        'username',
10094    ]
10095
10096    def __init__(
10097        self,
10098        bind_interface=None,
10099        database=None,
10100        egress_filter=None,
10101        healthy=None,
10102        hostname=None,
10103        id=None,
10104        name=None,
10105        override_database=None,
10106        password=None,
10107        port=None,
10108        port_override=None,
10109        schema=None,
10110        secret_store_id=None,
10111        tags=None,
10112        username=None,
10113    ):
10114        self.bind_interface = bind_interface if bind_interface is not None else ''
10115        '''
10116         Bind interface
10117        '''
10118        self.database = database if database is not None else ''
10119        self.egress_filter = egress_filter if egress_filter is not None else ''
10120        '''
10121         A filter applied to the routing logic to pin datasource to nodes.
10122        '''
10123        self.healthy = healthy if healthy is not None else False
10124        '''
10125         True if the datasource is reachable and the credentials are valid.
10126        '''
10127        self.hostname = hostname if hostname is not None else ''
10128        self.id = id if id is not None else ''
10129        '''
10130         Unique identifier of the Resource.
10131        '''
10132        self.name = name if name is not None else ''
10133        '''
10134         Unique human-readable name of the Resource.
10135        '''
10136        self.override_database = override_database if override_database is not None else False
10137        self.password = password if password is not None else ''
10138        self.port = port if port is not None else 0
10139        self.port_override = port_override if port_override is not None else 0
10140        self.schema = schema if schema is not None else ''
10141        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10142        '''
10143         ID of the secret store containing credentials for this resource, if any.
10144        '''
10145        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10146        '''
10147         Tags is a map of key, value pairs.
10148        '''
10149        self.username = username if username is not None else ''
10150
10151    def __repr__(self):
10152        return '<sdm.SQLServer ' + \
10153            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10154            'database: ' + repr(self.database) + ' ' +\
10155            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10156            'healthy: ' + repr(self.healthy) + ' ' +\
10157            'hostname: ' + repr(self.hostname) + ' ' +\
10158            'id: ' + repr(self.id) + ' ' +\
10159            'name: ' + repr(self.name) + ' ' +\
10160            'override_database: ' + repr(self.override_database) + ' ' +\
10161            'password: ' + repr(self.password) + ' ' +\
10162            'port: ' + repr(self.port) + ' ' +\
10163            'port_override: ' + repr(self.port_override) + ' ' +\
10164            'schema: ' + repr(self.schema) + ' ' +\
10165            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10166            'tags: ' + repr(self.tags) + ' ' +\
10167            'username: ' + repr(self.username) + ' ' +\
10168            '>'
10169
10170    def to_dict(self):
10171        return {
10172            'bind_interface': self.bind_interface,
10173            'database': self.database,
10174            'egress_filter': self.egress_filter,
10175            'healthy': self.healthy,
10176            'hostname': self.hostname,
10177            'id': self.id,
10178            'name': self.name,
10179            'override_database': self.override_database,
10180            'password': self.password,
10181            'port': self.port,
10182            'port_override': self.port_override,
10183            'schema': self.schema,
10184            'secret_store_id': self.secret_store_id,
10185            'tags': self.tags,
10186            'username': self.username,
10187        }
10188
10189    @classmethod
10190    def from_dict(cls, d):
10191        return cls(
10192            bind_interface=d.get('bind_interface'),
10193            database=d.get('database'),
10194            egress_filter=d.get('egress_filter'),
10195            healthy=d.get('healthy'),
10196            hostname=d.get('hostname'),
10197            id=d.get('id'),
10198            name=d.get('name'),
10199            override_database=d.get('override_database'),
10200            password=d.get('password'),
10201            port=d.get('port'),
10202            port_override=d.get('port_override'),
10203            schema=d.get('schema'),
10204            secret_store_id=d.get('secret_store_id'),
10205            tags=d.get('tags'),
10206            username=d.get('username'),
10207        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
10096    def __init__(
10097        self,
10098        bind_interface=None,
10099        database=None,
10100        egress_filter=None,
10101        healthy=None,
10102        hostname=None,
10103        id=None,
10104        name=None,
10105        override_database=None,
10106        password=None,
10107        port=None,
10108        port_override=None,
10109        schema=None,
10110        secret_store_id=None,
10111        tags=None,
10112        username=None,
10113    ):
10114        self.bind_interface = bind_interface if bind_interface is not None else ''
10115        '''
10116         Bind interface
10117        '''
10118        self.database = database if database is not None else ''
10119        self.egress_filter = egress_filter if egress_filter is not None else ''
10120        '''
10121         A filter applied to the routing logic to pin datasource to nodes.
10122        '''
10123        self.healthy = healthy if healthy is not None else False
10124        '''
10125         True if the datasource is reachable and the credentials are valid.
10126        '''
10127        self.hostname = hostname if hostname is not None else ''
10128        self.id = id if id is not None else ''
10129        '''
10130         Unique identifier of the Resource.
10131        '''
10132        self.name = name if name is not None else ''
10133        '''
10134         Unique human-readable name of the Resource.
10135        '''
10136        self.override_database = override_database if override_database is not None else False
10137        self.password = password if password is not None else ''
10138        self.port = port if port is not None else 0
10139        self.port_override = port_override if port_override is not None else 0
10140        self.schema = schema if schema is not None else ''
10141        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10142        '''
10143         ID of the secret store containing credentials for this resource, if any.
10144        '''
10145        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10146        '''
10147         Tags is a map of key, value pairs.
10148        '''
10149        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10170    def to_dict(self):
10171        return {
10172            'bind_interface': self.bind_interface,
10173            'database': self.database,
10174            'egress_filter': self.egress_filter,
10175            'healthy': self.healthy,
10176            'hostname': self.hostname,
10177            'id': self.id,
10178            'name': self.name,
10179            'override_database': self.override_database,
10180            'password': self.password,
10181            'port': self.port,
10182            'port_override': self.port_override,
10183            'schema': self.schema,
10184            'secret_store_id': self.secret_store_id,
10185            'tags': self.tags,
10186            'username': self.username,
10187        }
@classmethod
def from_dict(cls, d)
10189    @classmethod
10190    def from_dict(cls, d):
10191        return cls(
10192            bind_interface=d.get('bind_interface'),
10193            database=d.get('database'),
10194            egress_filter=d.get('egress_filter'),
10195            healthy=d.get('healthy'),
10196            hostname=d.get('hostname'),
10197            id=d.get('id'),
10198            name=d.get('name'),
10199            override_database=d.get('override_database'),
10200            password=d.get('password'),
10201            port=d.get('port'),
10202            port_override=d.get('port_override'),
10203            schema=d.get('schema'),
10204            secret_store_id=d.get('secret_store_id'),
10205            tags=d.get('tags'),
10206            username=d.get('username'),
10207        )
class SSH:
10210class SSH:
10211    __slots__ = [
10212        'allow_deprecated_key_exchanges',
10213        'bind_interface',
10214        'egress_filter',
10215        'healthy',
10216        'hostname',
10217        'id',
10218        'key_type',
10219        'name',
10220        'port',
10221        'port_forwarding',
10222        'port_override',
10223        'public_key',
10224        'secret_store_id',
10225        'tags',
10226        'username',
10227    ]
10228
10229    def __init__(
10230        self,
10231        allow_deprecated_key_exchanges=None,
10232        bind_interface=None,
10233        egress_filter=None,
10234        healthy=None,
10235        hostname=None,
10236        id=None,
10237        key_type=None,
10238        name=None,
10239        port=None,
10240        port_forwarding=None,
10241        port_override=None,
10242        public_key=None,
10243        secret_store_id=None,
10244        tags=None,
10245        username=None,
10246    ):
10247        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10248        self.bind_interface = bind_interface if bind_interface is not None else ''
10249        '''
10250         Bind interface
10251        '''
10252        self.egress_filter = egress_filter if egress_filter is not None else ''
10253        '''
10254         A filter applied to the routing logic to pin datasource to nodes.
10255        '''
10256        self.healthy = healthy if healthy is not None else False
10257        '''
10258         True if the datasource is reachable and the credentials are valid.
10259        '''
10260        self.hostname = hostname if hostname is not None else ''
10261        self.id = id if id is not None else ''
10262        '''
10263         Unique identifier of the Resource.
10264        '''
10265        self.key_type = key_type if key_type is not None else ''
10266        self.name = name if name is not None else ''
10267        '''
10268         Unique human-readable name of the Resource.
10269        '''
10270        self.port = port if port is not None else 0
10271        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10272        self.port_override = port_override if port_override is not None else 0
10273        self.public_key = public_key if public_key is not None else ''
10274        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10275        '''
10276         ID of the secret store containing credentials for this resource, if any.
10277        '''
10278        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10279        '''
10280         Tags is a map of key, value pairs.
10281        '''
10282        self.username = username if username is not None else ''
10283
10284    def __repr__(self):
10285        return '<sdm.SSH ' + \
10286            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10287            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10288            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10289            'healthy: ' + repr(self.healthy) + ' ' +\
10290            'hostname: ' + repr(self.hostname) + ' ' +\
10291            'id: ' + repr(self.id) + ' ' +\
10292            'key_type: ' + repr(self.key_type) + ' ' +\
10293            'name: ' + repr(self.name) + ' ' +\
10294            'port: ' + repr(self.port) + ' ' +\
10295            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10296            'port_override: ' + repr(self.port_override) + ' ' +\
10297            'public_key: ' + repr(self.public_key) + ' ' +\
10298            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10299            'tags: ' + repr(self.tags) + ' ' +\
10300            'username: ' + repr(self.username) + ' ' +\
10301            '>'
10302
10303    def to_dict(self):
10304        return {
10305            'allow_deprecated_key_exchanges':
10306            self.allow_deprecated_key_exchanges,
10307            'bind_interface': self.bind_interface,
10308            'egress_filter': self.egress_filter,
10309            'healthy': self.healthy,
10310            'hostname': self.hostname,
10311            'id': self.id,
10312            'key_type': self.key_type,
10313            'name': self.name,
10314            'port': self.port,
10315            'port_forwarding': self.port_forwarding,
10316            'port_override': self.port_override,
10317            'public_key': self.public_key,
10318            'secret_store_id': self.secret_store_id,
10319            'tags': self.tags,
10320            'username': self.username,
10321        }
10322
10323    @classmethod
10324    def from_dict(cls, d):
10325        return cls(
10326            allow_deprecated_key_exchanges=d.get(
10327                'allow_deprecated_key_exchanges'),
10328            bind_interface=d.get('bind_interface'),
10329            egress_filter=d.get('egress_filter'),
10330            healthy=d.get('healthy'),
10331            hostname=d.get('hostname'),
10332            id=d.get('id'),
10333            key_type=d.get('key_type'),
10334            name=d.get('name'),
10335            port=d.get('port'),
10336            port_forwarding=d.get('port_forwarding'),
10337            port_override=d.get('port_override'),
10338            public_key=d.get('public_key'),
10339            secret_store_id=d.get('secret_store_id'),
10340            tags=d.get('tags'),
10341            username=d.get('username'),
10342        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
10229    def __init__(
10230        self,
10231        allow_deprecated_key_exchanges=None,
10232        bind_interface=None,
10233        egress_filter=None,
10234        healthy=None,
10235        hostname=None,
10236        id=None,
10237        key_type=None,
10238        name=None,
10239        port=None,
10240        port_forwarding=None,
10241        port_override=None,
10242        public_key=None,
10243        secret_store_id=None,
10244        tags=None,
10245        username=None,
10246    ):
10247        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10248        self.bind_interface = bind_interface if bind_interface is not None else ''
10249        '''
10250         Bind interface
10251        '''
10252        self.egress_filter = egress_filter if egress_filter is not None else ''
10253        '''
10254         A filter applied to the routing logic to pin datasource to nodes.
10255        '''
10256        self.healthy = healthy if healthy is not None else False
10257        '''
10258         True if the datasource is reachable and the credentials are valid.
10259        '''
10260        self.hostname = hostname if hostname is not None else ''
10261        self.id = id if id is not None else ''
10262        '''
10263         Unique identifier of the Resource.
10264        '''
10265        self.key_type = key_type if key_type is not None else ''
10266        self.name = name if name is not None else ''
10267        '''
10268         Unique human-readable name of the Resource.
10269        '''
10270        self.port = port if port is not None else 0
10271        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10272        self.port_override = port_override if port_override is not None else 0
10273        self.public_key = public_key if public_key is not None else ''
10274        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10275        '''
10276         ID of the secret store containing credentials for this resource, if any.
10277        '''
10278        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10279        '''
10280         Tags is a map of key, value pairs.
10281        '''
10282        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10303    def to_dict(self):
10304        return {
10305            'allow_deprecated_key_exchanges':
10306            self.allow_deprecated_key_exchanges,
10307            'bind_interface': self.bind_interface,
10308            'egress_filter': self.egress_filter,
10309            'healthy': self.healthy,
10310            'hostname': self.hostname,
10311            'id': self.id,
10312            'key_type': self.key_type,
10313            'name': self.name,
10314            'port': self.port,
10315            'port_forwarding': self.port_forwarding,
10316            'port_override': self.port_override,
10317            'public_key': self.public_key,
10318            'secret_store_id': self.secret_store_id,
10319            'tags': self.tags,
10320            'username': self.username,
10321        }
@classmethod
def from_dict(cls, d)
10323    @classmethod
10324    def from_dict(cls, d):
10325        return cls(
10326            allow_deprecated_key_exchanges=d.get(
10327                'allow_deprecated_key_exchanges'),
10328            bind_interface=d.get('bind_interface'),
10329            egress_filter=d.get('egress_filter'),
10330            healthy=d.get('healthy'),
10331            hostname=d.get('hostname'),
10332            id=d.get('id'),
10333            key_type=d.get('key_type'),
10334            name=d.get('name'),
10335            port=d.get('port'),
10336            port_forwarding=d.get('port_forwarding'),
10337            port_override=d.get('port_override'),
10338            public_key=d.get('public_key'),
10339            secret_store_id=d.get('secret_store_id'),
10340            tags=d.get('tags'),
10341            username=d.get('username'),
10342        )
class SSHCert:
10345class SSHCert:
10346    __slots__ = [
10347        'allow_deprecated_key_exchanges',
10348        'bind_interface',
10349        'egress_filter',
10350        'healthy',
10351        'hostname',
10352        'id',
10353        'key_type',
10354        'name',
10355        'port',
10356        'port_forwarding',
10357        'port_override',
10358        'remote_identity_group_id',
10359        'remote_identity_healthcheck_username',
10360        'secret_store_id',
10361        'tags',
10362        'username',
10363    ]
10364
10365    def __init__(
10366        self,
10367        allow_deprecated_key_exchanges=None,
10368        bind_interface=None,
10369        egress_filter=None,
10370        healthy=None,
10371        hostname=None,
10372        id=None,
10373        key_type=None,
10374        name=None,
10375        port=None,
10376        port_forwarding=None,
10377        port_override=None,
10378        remote_identity_group_id=None,
10379        remote_identity_healthcheck_username=None,
10380        secret_store_id=None,
10381        tags=None,
10382        username=None,
10383    ):
10384        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10385        self.bind_interface = bind_interface if bind_interface is not None else ''
10386        '''
10387         Bind interface
10388        '''
10389        self.egress_filter = egress_filter if egress_filter is not None else ''
10390        '''
10391         A filter applied to the routing logic to pin datasource to nodes.
10392        '''
10393        self.healthy = healthy if healthy is not None else False
10394        '''
10395         True if the datasource is reachable and the credentials are valid.
10396        '''
10397        self.hostname = hostname if hostname is not None else ''
10398        self.id = id if id is not None else ''
10399        '''
10400         Unique identifier of the Resource.
10401        '''
10402        self.key_type = key_type if key_type is not None else ''
10403        self.name = name if name is not None else ''
10404        '''
10405         Unique human-readable name of the Resource.
10406        '''
10407        self.port = port if port is not None else 0
10408        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10409        self.port_override = port_override if port_override is not None else 0
10410        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10411        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10412        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10413        '''
10414         ID of the secret store containing credentials for this resource, if any.
10415        '''
10416        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10417        '''
10418         Tags is a map of key, value pairs.
10419        '''
10420        self.username = username if username is not None else ''
10421
10422    def __repr__(self):
10423        return '<sdm.SSHCert ' + \
10424            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10425            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10426            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10427            'healthy: ' + repr(self.healthy) + ' ' +\
10428            'hostname: ' + repr(self.hostname) + ' ' +\
10429            'id: ' + repr(self.id) + ' ' +\
10430            'key_type: ' + repr(self.key_type) + ' ' +\
10431            'name: ' + repr(self.name) + ' ' +\
10432            'port: ' + repr(self.port) + ' ' +\
10433            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10434            'port_override: ' + repr(self.port_override) + ' ' +\
10435            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10436            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
10437            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10438            'tags: ' + repr(self.tags) + ' ' +\
10439            'username: ' + repr(self.username) + ' ' +\
10440            '>'
10441
10442    def to_dict(self):
10443        return {
10444            'allow_deprecated_key_exchanges':
10445            self.allow_deprecated_key_exchanges,
10446            'bind_interface': self.bind_interface,
10447            'egress_filter': self.egress_filter,
10448            'healthy': self.healthy,
10449            'hostname': self.hostname,
10450            'id': self.id,
10451            'key_type': self.key_type,
10452            'name': self.name,
10453            'port': self.port,
10454            'port_forwarding': self.port_forwarding,
10455            'port_override': self.port_override,
10456            'remote_identity_group_id': self.remote_identity_group_id,
10457            'remote_identity_healthcheck_username':
10458            self.remote_identity_healthcheck_username,
10459            'secret_store_id': self.secret_store_id,
10460            'tags': self.tags,
10461            'username': self.username,
10462        }
10463
10464    @classmethod
10465    def from_dict(cls, d):
10466        return cls(
10467            allow_deprecated_key_exchanges=d.get(
10468                'allow_deprecated_key_exchanges'),
10469            bind_interface=d.get('bind_interface'),
10470            egress_filter=d.get('egress_filter'),
10471            healthy=d.get('healthy'),
10472            hostname=d.get('hostname'),
10473            id=d.get('id'),
10474            key_type=d.get('key_type'),
10475            name=d.get('name'),
10476            port=d.get('port'),
10477            port_forwarding=d.get('port_forwarding'),
10478            port_override=d.get('port_override'),
10479            remote_identity_group_id=d.get('remote_identity_group_id'),
10480            remote_identity_healthcheck_username=d.get(
10481                'remote_identity_healthcheck_username'),
10482            secret_store_id=d.get('secret_store_id'),
10483            tags=d.get('tags'),
10484            username=d.get('username'),
10485        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
10365    def __init__(
10366        self,
10367        allow_deprecated_key_exchanges=None,
10368        bind_interface=None,
10369        egress_filter=None,
10370        healthy=None,
10371        hostname=None,
10372        id=None,
10373        key_type=None,
10374        name=None,
10375        port=None,
10376        port_forwarding=None,
10377        port_override=None,
10378        remote_identity_group_id=None,
10379        remote_identity_healthcheck_username=None,
10380        secret_store_id=None,
10381        tags=None,
10382        username=None,
10383    ):
10384        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10385        self.bind_interface = bind_interface if bind_interface is not None else ''
10386        '''
10387         Bind interface
10388        '''
10389        self.egress_filter = egress_filter if egress_filter is not None else ''
10390        '''
10391         A filter applied to the routing logic to pin datasource to nodes.
10392        '''
10393        self.healthy = healthy if healthy is not None else False
10394        '''
10395         True if the datasource is reachable and the credentials are valid.
10396        '''
10397        self.hostname = hostname if hostname is not None else ''
10398        self.id = id if id is not None else ''
10399        '''
10400         Unique identifier of the Resource.
10401        '''
10402        self.key_type = key_type if key_type is not None else ''
10403        self.name = name if name is not None else ''
10404        '''
10405         Unique human-readable name of the Resource.
10406        '''
10407        self.port = port if port is not None else 0
10408        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10409        self.port_override = port_override if port_override is not None else 0
10410        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10411        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10412        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10413        '''
10414         ID of the secret store containing credentials for this resource, if any.
10415        '''
10416        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10417        '''
10418         Tags is a map of key, value pairs.
10419        '''
10420        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10442    def to_dict(self):
10443        return {
10444            'allow_deprecated_key_exchanges':
10445            self.allow_deprecated_key_exchanges,
10446            'bind_interface': self.bind_interface,
10447            'egress_filter': self.egress_filter,
10448            'healthy': self.healthy,
10449            'hostname': self.hostname,
10450            'id': self.id,
10451            'key_type': self.key_type,
10452            'name': self.name,
10453            'port': self.port,
10454            'port_forwarding': self.port_forwarding,
10455            'port_override': self.port_override,
10456            'remote_identity_group_id': self.remote_identity_group_id,
10457            'remote_identity_healthcheck_username':
10458            self.remote_identity_healthcheck_username,
10459            'secret_store_id': self.secret_store_id,
10460            'tags': self.tags,
10461            'username': self.username,
10462        }
@classmethod
def from_dict(cls, d)
10464    @classmethod
10465    def from_dict(cls, d):
10466        return cls(
10467            allow_deprecated_key_exchanges=d.get(
10468                'allow_deprecated_key_exchanges'),
10469            bind_interface=d.get('bind_interface'),
10470            egress_filter=d.get('egress_filter'),
10471            healthy=d.get('healthy'),
10472            hostname=d.get('hostname'),
10473            id=d.get('id'),
10474            key_type=d.get('key_type'),
10475            name=d.get('name'),
10476            port=d.get('port'),
10477            port_forwarding=d.get('port_forwarding'),
10478            port_override=d.get('port_override'),
10479            remote_identity_group_id=d.get('remote_identity_group_id'),
10480            remote_identity_healthcheck_username=d.get(
10481                'remote_identity_healthcheck_username'),
10482            secret_store_id=d.get('secret_store_id'),
10483            tags=d.get('tags'),
10484            username=d.get('username'),
10485        )
class SSHCustomerKey:
10488class SSHCustomerKey:
10489    __slots__ = [
10490        'allow_deprecated_key_exchanges',
10491        'bind_interface',
10492        'egress_filter',
10493        'healthy',
10494        'hostname',
10495        'id',
10496        'name',
10497        'port',
10498        'port_forwarding',
10499        'port_override',
10500        'private_key',
10501        'secret_store_id',
10502        'tags',
10503        'username',
10504    ]
10505
10506    def __init__(
10507        self,
10508        allow_deprecated_key_exchanges=None,
10509        bind_interface=None,
10510        egress_filter=None,
10511        healthy=None,
10512        hostname=None,
10513        id=None,
10514        name=None,
10515        port=None,
10516        port_forwarding=None,
10517        port_override=None,
10518        private_key=None,
10519        secret_store_id=None,
10520        tags=None,
10521        username=None,
10522    ):
10523        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10524        self.bind_interface = bind_interface if bind_interface is not None else ''
10525        '''
10526         Bind interface
10527        '''
10528        self.egress_filter = egress_filter if egress_filter is not None else ''
10529        '''
10530         A filter applied to the routing logic to pin datasource to nodes.
10531        '''
10532        self.healthy = healthy if healthy is not None else False
10533        '''
10534         True if the datasource is reachable and the credentials are valid.
10535        '''
10536        self.hostname = hostname if hostname is not None else ''
10537        self.id = id if id is not None else ''
10538        '''
10539         Unique identifier of the Resource.
10540        '''
10541        self.name = name if name is not None else ''
10542        '''
10543         Unique human-readable name of the Resource.
10544        '''
10545        self.port = port if port is not None else 0
10546        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10547        self.port_override = port_override if port_override is not None else 0
10548        self.private_key = private_key if private_key is not None else ''
10549        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10550        '''
10551         ID of the secret store containing credentials for this resource, if any.
10552        '''
10553        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10554        '''
10555         Tags is a map of key, value pairs.
10556        '''
10557        self.username = username if username is not None else ''
10558
10559    def __repr__(self):
10560        return '<sdm.SSHCustomerKey ' + \
10561            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10562            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10563            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10564            'healthy: ' + repr(self.healthy) + ' ' +\
10565            'hostname: ' + repr(self.hostname) + ' ' +\
10566            'id: ' + repr(self.id) + ' ' +\
10567            'name: ' + repr(self.name) + ' ' +\
10568            'port: ' + repr(self.port) + ' ' +\
10569            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10570            'port_override: ' + repr(self.port_override) + ' ' +\
10571            'private_key: ' + repr(self.private_key) + ' ' +\
10572            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10573            'tags: ' + repr(self.tags) + ' ' +\
10574            'username: ' + repr(self.username) + ' ' +\
10575            '>'
10576
10577    def to_dict(self):
10578        return {
10579            'allow_deprecated_key_exchanges':
10580            self.allow_deprecated_key_exchanges,
10581            'bind_interface': self.bind_interface,
10582            'egress_filter': self.egress_filter,
10583            'healthy': self.healthy,
10584            'hostname': self.hostname,
10585            'id': self.id,
10586            'name': self.name,
10587            'port': self.port,
10588            'port_forwarding': self.port_forwarding,
10589            'port_override': self.port_override,
10590            'private_key': self.private_key,
10591            'secret_store_id': self.secret_store_id,
10592            'tags': self.tags,
10593            'username': self.username,
10594        }
10595
10596    @classmethod
10597    def from_dict(cls, d):
10598        return cls(
10599            allow_deprecated_key_exchanges=d.get(
10600                'allow_deprecated_key_exchanges'),
10601            bind_interface=d.get('bind_interface'),
10602            egress_filter=d.get('egress_filter'),
10603            healthy=d.get('healthy'),
10604            hostname=d.get('hostname'),
10605            id=d.get('id'),
10606            name=d.get('name'),
10607            port=d.get('port'),
10608            port_forwarding=d.get('port_forwarding'),
10609            port_override=d.get('port_override'),
10610            private_key=d.get('private_key'),
10611            secret_store_id=d.get('secret_store_id'),
10612            tags=d.get('tags'),
10613            username=d.get('username'),
10614        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
10506    def __init__(
10507        self,
10508        allow_deprecated_key_exchanges=None,
10509        bind_interface=None,
10510        egress_filter=None,
10511        healthy=None,
10512        hostname=None,
10513        id=None,
10514        name=None,
10515        port=None,
10516        port_forwarding=None,
10517        port_override=None,
10518        private_key=None,
10519        secret_store_id=None,
10520        tags=None,
10521        username=None,
10522    ):
10523        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10524        self.bind_interface = bind_interface if bind_interface is not None else ''
10525        '''
10526         Bind interface
10527        '''
10528        self.egress_filter = egress_filter if egress_filter is not None else ''
10529        '''
10530         A filter applied to the routing logic to pin datasource to nodes.
10531        '''
10532        self.healthy = healthy if healthy is not None else False
10533        '''
10534         True if the datasource is reachable and the credentials are valid.
10535        '''
10536        self.hostname = hostname if hostname is not None else ''
10537        self.id = id if id is not None else ''
10538        '''
10539         Unique identifier of the Resource.
10540        '''
10541        self.name = name if name is not None else ''
10542        '''
10543         Unique human-readable name of the Resource.
10544        '''
10545        self.port = port if port is not None else 0
10546        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10547        self.port_override = port_override if port_override is not None else 0
10548        self.private_key = private_key if private_key is not None else ''
10549        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10550        '''
10551         ID of the secret store containing credentials for this resource, if any.
10552        '''
10553        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10554        '''
10555         Tags is a map of key, value pairs.
10556        '''
10557        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10577    def to_dict(self):
10578        return {
10579            'allow_deprecated_key_exchanges':
10580            self.allow_deprecated_key_exchanges,
10581            'bind_interface': self.bind_interface,
10582            'egress_filter': self.egress_filter,
10583            'healthy': self.healthy,
10584            'hostname': self.hostname,
10585            'id': self.id,
10586            'name': self.name,
10587            'port': self.port,
10588            'port_forwarding': self.port_forwarding,
10589            'port_override': self.port_override,
10590            'private_key': self.private_key,
10591            'secret_store_id': self.secret_store_id,
10592            'tags': self.tags,
10593            'username': self.username,
10594        }
@classmethod
def from_dict(cls, d)
10596    @classmethod
10597    def from_dict(cls, d):
10598        return cls(
10599            allow_deprecated_key_exchanges=d.get(
10600                'allow_deprecated_key_exchanges'),
10601            bind_interface=d.get('bind_interface'),
10602            egress_filter=d.get('egress_filter'),
10603            healthy=d.get('healthy'),
10604            hostname=d.get('hostname'),
10605            id=d.get('id'),
10606            name=d.get('name'),
10607            port=d.get('port'),
10608            port_forwarding=d.get('port_forwarding'),
10609            port_override=d.get('port_override'),
10610            private_key=d.get('private_key'),
10611            secret_store_id=d.get('secret_store_id'),
10612            tags=d.get('tags'),
10613            username=d.get('username'),
10614        )
class SecretStoreCreateResponse:
10617class SecretStoreCreateResponse:
10618    '''
10619         SecretStoreCreateResponse reports how the SecretStores were created in the system.
10620    '''
10621    __slots__ = [
10622        'meta',
10623        'rate_limit',
10624        'secret_store',
10625    ]
10626
10627    def __init__(
10628        self,
10629        meta=None,
10630        rate_limit=None,
10631        secret_store=None,
10632    ):
10633        self.meta = meta if meta is not None else None
10634        '''
10635         Reserved for future use.
10636        '''
10637        self.rate_limit = rate_limit if rate_limit is not None else None
10638        '''
10639         Rate limit information.
10640        '''
10641        self.secret_store = secret_store if secret_store is not None else None
10642        '''
10643         The created SecretStore.
10644        '''
10645
10646    def __repr__(self):
10647        return '<sdm.SecretStoreCreateResponse ' + \
10648            'meta: ' + repr(self.meta) + ' ' +\
10649            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10650            'secret_store: ' + repr(self.secret_store) + ' ' +\
10651            '>'
10652
10653    def to_dict(self):
10654        return {
10655            'meta': self.meta,
10656            'rate_limit': self.rate_limit,
10657            'secret_store': self.secret_store,
10658        }
10659
10660    @classmethod
10661    def from_dict(cls, d):
10662        return cls(
10663            meta=d.get('meta'),
10664            rate_limit=d.get('rate_limit'),
10665            secret_store=d.get('secret_store'),
10666        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
10627    def __init__(
10628        self,
10629        meta=None,
10630        rate_limit=None,
10631        secret_store=None,
10632    ):
10633        self.meta = meta if meta is not None else None
10634        '''
10635         Reserved for future use.
10636        '''
10637        self.rate_limit = rate_limit if rate_limit is not None else None
10638        '''
10639         Rate limit information.
10640        '''
10641        self.secret_store = secret_store if secret_store is not None else None
10642        '''
10643         The created SecretStore.
10644        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
10653    def to_dict(self):
10654        return {
10655            'meta': self.meta,
10656            'rate_limit': self.rate_limit,
10657            'secret_store': self.secret_store,
10658        }
@classmethod
def from_dict(cls, d)
10660    @classmethod
10661    def from_dict(cls, d):
10662        return cls(
10663            meta=d.get('meta'),
10664            rate_limit=d.get('rate_limit'),
10665            secret_store=d.get('secret_store'),
10666        )
class SecretStoreDeleteResponse:
10669class SecretStoreDeleteResponse:
10670    '''
10671         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
10672    '''
10673    __slots__ = [
10674        'meta',
10675        'rate_limit',
10676    ]
10677
10678    def __init__(
10679        self,
10680        meta=None,
10681        rate_limit=None,
10682    ):
10683        self.meta = meta if meta is not None else None
10684        '''
10685         Reserved for future use.
10686        '''
10687        self.rate_limit = rate_limit if rate_limit is not None else None
10688        '''
10689         Rate limit information.
10690        '''
10691
10692    def __repr__(self):
10693        return '<sdm.SecretStoreDeleteResponse ' + \
10694            'meta: ' + repr(self.meta) + ' ' +\
10695            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10696            '>'
10697
10698    def to_dict(self):
10699        return {
10700            'meta': self.meta,
10701            'rate_limit': self.rate_limit,
10702        }
10703
10704    @classmethod
10705    def from_dict(cls, d):
10706        return cls(
10707            meta=d.get('meta'),
10708            rate_limit=d.get('rate_limit'),
10709        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
10678    def __init__(
10679        self,
10680        meta=None,
10681        rate_limit=None,
10682    ):
10683        self.meta = meta if meta is not None else None
10684        '''
10685         Reserved for future use.
10686        '''
10687        self.rate_limit = rate_limit if rate_limit is not None else None
10688        '''
10689         Rate limit information.
10690        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10698    def to_dict(self):
10699        return {
10700            'meta': self.meta,
10701            'rate_limit': self.rate_limit,
10702        }
@classmethod
def from_dict(cls, d)
10704    @classmethod
10705    def from_dict(cls, d):
10706        return cls(
10707            meta=d.get('meta'),
10708            rate_limit=d.get('rate_limit'),
10709        )
class SecretStoreGetResponse:
10712class SecretStoreGetResponse:
10713    '''
10714         SecretStoreGetResponse returns a requested SecretStore.
10715    '''
10716    __slots__ = [
10717        'meta',
10718        'rate_limit',
10719        'secret_store',
10720    ]
10721
10722    def __init__(
10723        self,
10724        meta=None,
10725        rate_limit=None,
10726        secret_store=None,
10727    ):
10728        self.meta = meta if meta is not None else None
10729        '''
10730         Reserved for future use.
10731        '''
10732        self.rate_limit = rate_limit if rate_limit is not None else None
10733        '''
10734         Rate limit information.
10735        '''
10736        self.secret_store = secret_store if secret_store is not None else None
10737        '''
10738         The requested SecretStore.
10739        '''
10740
10741    def __repr__(self):
10742        return '<sdm.SecretStoreGetResponse ' + \
10743            'meta: ' + repr(self.meta) + ' ' +\
10744            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10745            'secret_store: ' + repr(self.secret_store) + ' ' +\
10746            '>'
10747
10748    def to_dict(self):
10749        return {
10750            'meta': self.meta,
10751            'rate_limit': self.rate_limit,
10752            'secret_store': self.secret_store,
10753        }
10754
10755    @classmethod
10756    def from_dict(cls, d):
10757        return cls(
10758            meta=d.get('meta'),
10759            rate_limit=d.get('rate_limit'),
10760            secret_store=d.get('secret_store'),
10761        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
10722    def __init__(
10723        self,
10724        meta=None,
10725        rate_limit=None,
10726        secret_store=None,
10727    ):
10728        self.meta = meta if meta is not None else None
10729        '''
10730         Reserved for future use.
10731        '''
10732        self.rate_limit = rate_limit if rate_limit is not None else None
10733        '''
10734         Rate limit information.
10735        '''
10736        self.secret_store = secret_store if secret_store is not None else None
10737        '''
10738         The requested SecretStore.
10739        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
10748    def to_dict(self):
10749        return {
10750            'meta': self.meta,
10751            'rate_limit': self.rate_limit,
10752            'secret_store': self.secret_store,
10753        }
@classmethod
def from_dict(cls, d)
10755    @classmethod
10756    def from_dict(cls, d):
10757        return cls(
10758            meta=d.get('meta'),
10759            rate_limit=d.get('rate_limit'),
10760            secret_store=d.get('secret_store'),
10761        )
class SecretStoreUpdateResponse:
10764class SecretStoreUpdateResponse:
10765    '''
10766         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
10767     a SecretStoreUpdateRequest.
10768    '''
10769    __slots__ = [
10770        'meta',
10771        'rate_limit',
10772        'secret_store',
10773    ]
10774
10775    def __init__(
10776        self,
10777        meta=None,
10778        rate_limit=None,
10779        secret_store=None,
10780    ):
10781        self.meta = meta if meta is not None else None
10782        '''
10783         Reserved for future use.
10784        '''
10785        self.rate_limit = rate_limit if rate_limit is not None else None
10786        '''
10787         Rate limit information.
10788        '''
10789        self.secret_store = secret_store if secret_store is not None else None
10790        '''
10791         The updated SecretStore.
10792        '''
10793
10794    def __repr__(self):
10795        return '<sdm.SecretStoreUpdateResponse ' + \
10796            'meta: ' + repr(self.meta) + ' ' +\
10797            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10798            'secret_store: ' + repr(self.secret_store) + ' ' +\
10799            '>'
10800
10801    def to_dict(self):
10802        return {
10803            'meta': self.meta,
10804            'rate_limit': self.rate_limit,
10805            'secret_store': self.secret_store,
10806        }
10807
10808    @classmethod
10809    def from_dict(cls, d):
10810        return cls(
10811            meta=d.get('meta'),
10812            rate_limit=d.get('rate_limit'),
10813            secret_store=d.get('secret_store'),
10814        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
10775    def __init__(
10776        self,
10777        meta=None,
10778        rate_limit=None,
10779        secret_store=None,
10780    ):
10781        self.meta = meta if meta is not None else None
10782        '''
10783         Reserved for future use.
10784        '''
10785        self.rate_limit = rate_limit if rate_limit is not None else None
10786        '''
10787         Rate limit information.
10788        '''
10789        self.secret_store = secret_store if secret_store is not None else None
10790        '''
10791         The updated SecretStore.
10792        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
10801    def to_dict(self):
10802        return {
10803            'meta': self.meta,
10804            'rate_limit': self.rate_limit,
10805            'secret_store': self.secret_store,
10806        }
@classmethod
def from_dict(cls, d)
10808    @classmethod
10809    def from_dict(cls, d):
10810        return cls(
10811            meta=d.get('meta'),
10812            rate_limit=d.get('rate_limit'),
10813            secret_store=d.get('secret_store'),
10814        )
class Service:
10817class Service:
10818    '''
10819         A Service is a service account that can connect to resources they are granted
10820     directly, or granted via roles. Services are typically automated jobs.
10821    '''
10822    __slots__ = [
10823        'id',
10824        'name',
10825        'suspended',
10826        'tags',
10827    ]
10828
10829    def __init__(
10830        self,
10831        id=None,
10832        name=None,
10833        suspended=None,
10834        tags=None,
10835    ):
10836        self.id = id if id is not None else ''
10837        '''
10838         Unique identifier of the Service.
10839        '''
10840        self.name = name if name is not None else ''
10841        '''
10842         Unique human-readable name of the Service.
10843        '''
10844        self.suspended = suspended if suspended is not None else False
10845        '''
10846         The Service's suspended state.
10847        '''
10848        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10849        '''
10850         Tags is a map of key, value pairs.
10851        '''
10852
10853    def __repr__(self):
10854        return '<sdm.Service ' + \
10855            'id: ' + repr(self.id) + ' ' +\
10856            'name: ' + repr(self.name) + ' ' +\
10857            'suspended: ' + repr(self.suspended) + ' ' +\
10858            'tags: ' + repr(self.tags) + ' ' +\
10859            '>'
10860
10861    def to_dict(self):
10862        return {
10863            'id': self.id,
10864            'name': self.name,
10865            'suspended': self.suspended,
10866            'tags': self.tags,
10867        }
10868
10869    @classmethod
10870    def from_dict(cls, d):
10871        return cls(
10872            id=d.get('id'),
10873            name=d.get('name'),
10874            suspended=d.get('suspended'),
10875            tags=d.get('tags'),
10876        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
10829    def __init__(
10830        self,
10831        id=None,
10832        name=None,
10833        suspended=None,
10834        tags=None,
10835    ):
10836        self.id = id if id is not None else ''
10837        '''
10838         Unique identifier of the Service.
10839        '''
10840        self.name = name if name is not None else ''
10841        '''
10842         Unique human-readable name of the Service.
10843        '''
10844        self.suspended = suspended if suspended is not None else False
10845        '''
10846         The Service's suspended state.
10847        '''
10848        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10849        '''
10850         Tags is a map of key, value pairs.
10851        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10861    def to_dict(self):
10862        return {
10863            'id': self.id,
10864            'name': self.name,
10865            'suspended': self.suspended,
10866            'tags': self.tags,
10867        }
@classmethod
def from_dict(cls, d)
10869    @classmethod
10870    def from_dict(cls, d):
10871        return cls(
10872            id=d.get('id'),
10873            name=d.get('name'),
10874            suspended=d.get('suspended'),
10875            tags=d.get('tags'),
10876        )
class SingleStore:
10879class SingleStore:
10880    __slots__ = [
10881        'bind_interface',
10882        'database',
10883        'egress_filter',
10884        'healthy',
10885        'hostname',
10886        'id',
10887        'name',
10888        'password',
10889        'port',
10890        'port_override',
10891        'secret_store_id',
10892        'tags',
10893        'username',
10894    ]
10895
10896    def __init__(
10897        self,
10898        bind_interface=None,
10899        database=None,
10900        egress_filter=None,
10901        healthy=None,
10902        hostname=None,
10903        id=None,
10904        name=None,
10905        password=None,
10906        port=None,
10907        port_override=None,
10908        secret_store_id=None,
10909        tags=None,
10910        username=None,
10911    ):
10912        self.bind_interface = bind_interface if bind_interface is not None else ''
10913        '''
10914         Bind interface
10915        '''
10916        self.database = database if database is not None else ''
10917        self.egress_filter = egress_filter if egress_filter is not None else ''
10918        '''
10919         A filter applied to the routing logic to pin datasource to nodes.
10920        '''
10921        self.healthy = healthy if healthy is not None else False
10922        '''
10923         True if the datasource is reachable and the credentials are valid.
10924        '''
10925        self.hostname = hostname if hostname is not None else ''
10926        self.id = id if id is not None else ''
10927        '''
10928         Unique identifier of the Resource.
10929        '''
10930        self.name = name if name is not None else ''
10931        '''
10932         Unique human-readable name of the Resource.
10933        '''
10934        self.password = password if password is not None else ''
10935        self.port = port if port is not None else 0
10936        self.port_override = port_override if port_override is not None else 0
10937        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10938        '''
10939         ID of the secret store containing credentials for this resource, if any.
10940        '''
10941        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10942        '''
10943         Tags is a map of key, value pairs.
10944        '''
10945        self.username = username if username is not None else ''
10946
10947    def __repr__(self):
10948        return '<sdm.SingleStore ' + \
10949            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10950            'database: ' + repr(self.database) + ' ' +\
10951            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10952            'healthy: ' + repr(self.healthy) + ' ' +\
10953            'hostname: ' + repr(self.hostname) + ' ' +\
10954            'id: ' + repr(self.id) + ' ' +\
10955            'name: ' + repr(self.name) + ' ' +\
10956            'password: ' + repr(self.password) + ' ' +\
10957            'port: ' + repr(self.port) + ' ' +\
10958            'port_override: ' + repr(self.port_override) + ' ' +\
10959            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10960            'tags: ' + repr(self.tags) + ' ' +\
10961            'username: ' + repr(self.username) + ' ' +\
10962            '>'
10963
10964    def to_dict(self):
10965        return {
10966            'bind_interface': self.bind_interface,
10967            'database': self.database,
10968            'egress_filter': self.egress_filter,
10969            'healthy': self.healthy,
10970            'hostname': self.hostname,
10971            'id': self.id,
10972            'name': self.name,
10973            'password': self.password,
10974            'port': self.port,
10975            'port_override': self.port_override,
10976            'secret_store_id': self.secret_store_id,
10977            'tags': self.tags,
10978            'username': self.username,
10979        }
10980
10981    @classmethod
10982    def from_dict(cls, d):
10983        return cls(
10984            bind_interface=d.get('bind_interface'),
10985            database=d.get('database'),
10986            egress_filter=d.get('egress_filter'),
10987            healthy=d.get('healthy'),
10988            hostname=d.get('hostname'),
10989            id=d.get('id'),
10990            name=d.get('name'),
10991            password=d.get('password'),
10992            port=d.get('port'),
10993            port_override=d.get('port_override'),
10994            secret_store_id=d.get('secret_store_id'),
10995            tags=d.get('tags'),
10996            username=d.get('username'),
10997        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
10896    def __init__(
10897        self,
10898        bind_interface=None,
10899        database=None,
10900        egress_filter=None,
10901        healthy=None,
10902        hostname=None,
10903        id=None,
10904        name=None,
10905        password=None,
10906        port=None,
10907        port_override=None,
10908        secret_store_id=None,
10909        tags=None,
10910        username=None,
10911    ):
10912        self.bind_interface = bind_interface if bind_interface is not None else ''
10913        '''
10914         Bind interface
10915        '''
10916        self.database = database if database is not None else ''
10917        self.egress_filter = egress_filter if egress_filter is not None else ''
10918        '''
10919         A filter applied to the routing logic to pin datasource to nodes.
10920        '''
10921        self.healthy = healthy if healthy is not None else False
10922        '''
10923         True if the datasource is reachable and the credentials are valid.
10924        '''
10925        self.hostname = hostname if hostname is not None else ''
10926        self.id = id if id is not None else ''
10927        '''
10928         Unique identifier of the Resource.
10929        '''
10930        self.name = name if name is not None else ''
10931        '''
10932         Unique human-readable name of the Resource.
10933        '''
10934        self.password = password if password is not None else ''
10935        self.port = port if port is not None else 0
10936        self.port_override = port_override if port_override is not None else 0
10937        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10938        '''
10939         ID of the secret store containing credentials for this resource, if any.
10940        '''
10941        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10942        '''
10943         Tags is a map of key, value pairs.
10944        '''
10945        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10964    def to_dict(self):
10965        return {
10966            'bind_interface': self.bind_interface,
10967            'database': self.database,
10968            'egress_filter': self.egress_filter,
10969            'healthy': self.healthy,
10970            'hostname': self.hostname,
10971            'id': self.id,
10972            'name': self.name,
10973            'password': self.password,
10974            'port': self.port,
10975            'port_override': self.port_override,
10976            'secret_store_id': self.secret_store_id,
10977            'tags': self.tags,
10978            'username': self.username,
10979        }
@classmethod
def from_dict(cls, d)
10981    @classmethod
10982    def from_dict(cls, d):
10983        return cls(
10984            bind_interface=d.get('bind_interface'),
10985            database=d.get('database'),
10986            egress_filter=d.get('egress_filter'),
10987            healthy=d.get('healthy'),
10988            hostname=d.get('hostname'),
10989            id=d.get('id'),
10990            name=d.get('name'),
10991            password=d.get('password'),
10992            port=d.get('port'),
10993            port_override=d.get('port_override'),
10994            secret_store_id=d.get('secret_store_id'),
10995            tags=d.get('tags'),
10996            username=d.get('username'),
10997        )
class Snowflake:
11000class Snowflake:
11001    __slots__ = [
11002        'bind_interface',
11003        'database',
11004        'egress_filter',
11005        'healthy',
11006        'hostname',
11007        'id',
11008        'name',
11009        'password',
11010        'port_override',
11011        'schema',
11012        'secret_store_id',
11013        'tags',
11014        'username',
11015    ]
11016
11017    def __init__(
11018        self,
11019        bind_interface=None,
11020        database=None,
11021        egress_filter=None,
11022        healthy=None,
11023        hostname=None,
11024        id=None,
11025        name=None,
11026        password=None,
11027        port_override=None,
11028        schema=None,
11029        secret_store_id=None,
11030        tags=None,
11031        username=None,
11032    ):
11033        self.bind_interface = bind_interface if bind_interface is not None else ''
11034        '''
11035         Bind interface
11036        '''
11037        self.database = database if database is not None else ''
11038        self.egress_filter = egress_filter if egress_filter is not None else ''
11039        '''
11040         A filter applied to the routing logic to pin datasource to nodes.
11041        '''
11042        self.healthy = healthy if healthy is not None else False
11043        '''
11044         True if the datasource is reachable and the credentials are valid.
11045        '''
11046        self.hostname = hostname if hostname is not None else ''
11047        self.id = id if id is not None else ''
11048        '''
11049         Unique identifier of the Resource.
11050        '''
11051        self.name = name if name is not None else ''
11052        '''
11053         Unique human-readable name of the Resource.
11054        '''
11055        self.password = password if password is not None else ''
11056        self.port_override = port_override if port_override is not None else 0
11057        self.schema = schema if schema is not None else ''
11058        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11059        '''
11060         ID of the secret store containing credentials for this resource, if any.
11061        '''
11062        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11063        '''
11064         Tags is a map of key, value pairs.
11065        '''
11066        self.username = username if username is not None else ''
11067
11068    def __repr__(self):
11069        return '<sdm.Snowflake ' + \
11070            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11071            'database: ' + repr(self.database) + ' ' +\
11072            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11073            'healthy: ' + repr(self.healthy) + ' ' +\
11074            'hostname: ' + repr(self.hostname) + ' ' +\
11075            'id: ' + repr(self.id) + ' ' +\
11076            'name: ' + repr(self.name) + ' ' +\
11077            'password: ' + repr(self.password) + ' ' +\
11078            'port_override: ' + repr(self.port_override) + ' ' +\
11079            'schema: ' + repr(self.schema) + ' ' +\
11080            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11081            'tags: ' + repr(self.tags) + ' ' +\
11082            'username: ' + repr(self.username) + ' ' +\
11083            '>'
11084
11085    def to_dict(self):
11086        return {
11087            'bind_interface': self.bind_interface,
11088            'database': self.database,
11089            'egress_filter': self.egress_filter,
11090            'healthy': self.healthy,
11091            'hostname': self.hostname,
11092            'id': self.id,
11093            'name': self.name,
11094            'password': self.password,
11095            'port_override': self.port_override,
11096            'schema': self.schema,
11097            'secret_store_id': self.secret_store_id,
11098            'tags': self.tags,
11099            'username': self.username,
11100        }
11101
11102    @classmethod
11103    def from_dict(cls, d):
11104        return cls(
11105            bind_interface=d.get('bind_interface'),
11106            database=d.get('database'),
11107            egress_filter=d.get('egress_filter'),
11108            healthy=d.get('healthy'),
11109            hostname=d.get('hostname'),
11110            id=d.get('id'),
11111            name=d.get('name'),
11112            password=d.get('password'),
11113            port_override=d.get('port_override'),
11114            schema=d.get('schema'),
11115            secret_store_id=d.get('secret_store_id'),
11116            tags=d.get('tags'),
11117            username=d.get('username'),
11118        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11017    def __init__(
11018        self,
11019        bind_interface=None,
11020        database=None,
11021        egress_filter=None,
11022        healthy=None,
11023        hostname=None,
11024        id=None,
11025        name=None,
11026        password=None,
11027        port_override=None,
11028        schema=None,
11029        secret_store_id=None,
11030        tags=None,
11031        username=None,
11032    ):
11033        self.bind_interface = bind_interface if bind_interface is not None else ''
11034        '''
11035         Bind interface
11036        '''
11037        self.database = database if database is not None else ''
11038        self.egress_filter = egress_filter if egress_filter is not None else ''
11039        '''
11040         A filter applied to the routing logic to pin datasource to nodes.
11041        '''
11042        self.healthy = healthy if healthy is not None else False
11043        '''
11044         True if the datasource is reachable and the credentials are valid.
11045        '''
11046        self.hostname = hostname if hostname is not None else ''
11047        self.id = id if id is not None else ''
11048        '''
11049         Unique identifier of the Resource.
11050        '''
11051        self.name = name if name is not None else ''
11052        '''
11053         Unique human-readable name of the Resource.
11054        '''
11055        self.password = password if password is not None else ''
11056        self.port_override = port_override if port_override is not None else 0
11057        self.schema = schema if schema is not None else ''
11058        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11059        '''
11060         ID of the secret store containing credentials for this resource, if any.
11061        '''
11062        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11063        '''
11064         Tags is a map of key, value pairs.
11065        '''
11066        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11085    def to_dict(self):
11086        return {
11087            'bind_interface': self.bind_interface,
11088            'database': self.database,
11089            'egress_filter': self.egress_filter,
11090            'healthy': self.healthy,
11091            'hostname': self.hostname,
11092            'id': self.id,
11093            'name': self.name,
11094            'password': self.password,
11095            'port_override': self.port_override,
11096            'schema': self.schema,
11097            'secret_store_id': self.secret_store_id,
11098            'tags': self.tags,
11099            'username': self.username,
11100        }
@classmethod
def from_dict(cls, d)
11102    @classmethod
11103    def from_dict(cls, d):
11104        return cls(
11105            bind_interface=d.get('bind_interface'),
11106            database=d.get('database'),
11107            egress_filter=d.get('egress_filter'),
11108            healthy=d.get('healthy'),
11109            hostname=d.get('hostname'),
11110            id=d.get('id'),
11111            name=d.get('name'),
11112            password=d.get('password'),
11113            port_override=d.get('port_override'),
11114            schema=d.get('schema'),
11115            secret_store_id=d.get('secret_store_id'),
11116            tags=d.get('tags'),
11117            username=d.get('username'),
11118        )
class Sybase:
11121class Sybase:
11122    __slots__ = [
11123        'bind_interface',
11124        'egress_filter',
11125        'healthy',
11126        'hostname',
11127        'id',
11128        'name',
11129        'password',
11130        'port',
11131        'port_override',
11132        'secret_store_id',
11133        'tags',
11134        'username',
11135    ]
11136
11137    def __init__(
11138        self,
11139        bind_interface=None,
11140        egress_filter=None,
11141        healthy=None,
11142        hostname=None,
11143        id=None,
11144        name=None,
11145        password=None,
11146        port=None,
11147        port_override=None,
11148        secret_store_id=None,
11149        tags=None,
11150        username=None,
11151    ):
11152        self.bind_interface = bind_interface if bind_interface is not None else ''
11153        '''
11154         Bind interface
11155        '''
11156        self.egress_filter = egress_filter if egress_filter is not None else ''
11157        '''
11158         A filter applied to the routing logic to pin datasource to nodes.
11159        '''
11160        self.healthy = healthy if healthy is not None else False
11161        '''
11162         True if the datasource is reachable and the credentials are valid.
11163        '''
11164        self.hostname = hostname if hostname is not None else ''
11165        self.id = id if id is not None else ''
11166        '''
11167         Unique identifier of the Resource.
11168        '''
11169        self.name = name if name is not None else ''
11170        '''
11171         Unique human-readable name of the Resource.
11172        '''
11173        self.password = password if password is not None else ''
11174        self.port = port if port is not None else 0
11175        self.port_override = port_override if port_override is not None else 0
11176        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11177        '''
11178         ID of the secret store containing credentials for this resource, if any.
11179        '''
11180        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11181        '''
11182         Tags is a map of key, value pairs.
11183        '''
11184        self.username = username if username is not None else ''
11185
11186    def __repr__(self):
11187        return '<sdm.Sybase ' + \
11188            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11189            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11190            'healthy: ' + repr(self.healthy) + ' ' +\
11191            'hostname: ' + repr(self.hostname) + ' ' +\
11192            'id: ' + repr(self.id) + ' ' +\
11193            'name: ' + repr(self.name) + ' ' +\
11194            'password: ' + repr(self.password) + ' ' +\
11195            'port: ' + repr(self.port) + ' ' +\
11196            'port_override: ' + repr(self.port_override) + ' ' +\
11197            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11198            'tags: ' + repr(self.tags) + ' ' +\
11199            'username: ' + repr(self.username) + ' ' +\
11200            '>'
11201
11202    def to_dict(self):
11203        return {
11204            'bind_interface': self.bind_interface,
11205            'egress_filter': self.egress_filter,
11206            'healthy': self.healthy,
11207            'hostname': self.hostname,
11208            'id': self.id,
11209            'name': self.name,
11210            'password': self.password,
11211            'port': self.port,
11212            'port_override': self.port_override,
11213            'secret_store_id': self.secret_store_id,
11214            'tags': self.tags,
11215            'username': self.username,
11216        }
11217
11218    @classmethod
11219    def from_dict(cls, d):
11220        return cls(
11221            bind_interface=d.get('bind_interface'),
11222            egress_filter=d.get('egress_filter'),
11223            healthy=d.get('healthy'),
11224            hostname=d.get('hostname'),
11225            id=d.get('id'),
11226            name=d.get('name'),
11227            password=d.get('password'),
11228            port=d.get('port'),
11229            port_override=d.get('port_override'),
11230            secret_store_id=d.get('secret_store_id'),
11231            tags=d.get('tags'),
11232            username=d.get('username'),
11233        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11137    def __init__(
11138        self,
11139        bind_interface=None,
11140        egress_filter=None,
11141        healthy=None,
11142        hostname=None,
11143        id=None,
11144        name=None,
11145        password=None,
11146        port=None,
11147        port_override=None,
11148        secret_store_id=None,
11149        tags=None,
11150        username=None,
11151    ):
11152        self.bind_interface = bind_interface if bind_interface is not None else ''
11153        '''
11154         Bind interface
11155        '''
11156        self.egress_filter = egress_filter if egress_filter is not None else ''
11157        '''
11158         A filter applied to the routing logic to pin datasource to nodes.
11159        '''
11160        self.healthy = healthy if healthy is not None else False
11161        '''
11162         True if the datasource is reachable and the credentials are valid.
11163        '''
11164        self.hostname = hostname if hostname is not None else ''
11165        self.id = id if id is not None else ''
11166        '''
11167         Unique identifier of the Resource.
11168        '''
11169        self.name = name if name is not None else ''
11170        '''
11171         Unique human-readable name of the Resource.
11172        '''
11173        self.password = password if password is not None else ''
11174        self.port = port if port is not None else 0
11175        self.port_override = port_override if port_override is not None else 0
11176        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11177        '''
11178         ID of the secret store containing credentials for this resource, if any.
11179        '''
11180        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11181        '''
11182         Tags is a map of key, value pairs.
11183        '''
11184        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11202    def to_dict(self):
11203        return {
11204            'bind_interface': self.bind_interface,
11205            'egress_filter': self.egress_filter,
11206            'healthy': self.healthy,
11207            'hostname': self.hostname,
11208            'id': self.id,
11209            'name': self.name,
11210            'password': self.password,
11211            'port': self.port,
11212            'port_override': self.port_override,
11213            'secret_store_id': self.secret_store_id,
11214            'tags': self.tags,
11215            'username': self.username,
11216        }
@classmethod
def from_dict(cls, d)
11218    @classmethod
11219    def from_dict(cls, d):
11220        return cls(
11221            bind_interface=d.get('bind_interface'),
11222            egress_filter=d.get('egress_filter'),
11223            healthy=d.get('healthy'),
11224            hostname=d.get('hostname'),
11225            id=d.get('id'),
11226            name=d.get('name'),
11227            password=d.get('password'),
11228            port=d.get('port'),
11229            port_override=d.get('port_override'),
11230            secret_store_id=d.get('secret_store_id'),
11231            tags=d.get('tags'),
11232            username=d.get('username'),
11233        )
class SybaseIQ:
11236class SybaseIQ:
11237    __slots__ = [
11238        'bind_interface',
11239        'egress_filter',
11240        'healthy',
11241        'hostname',
11242        'id',
11243        'name',
11244        'password',
11245        'port',
11246        'port_override',
11247        'secret_store_id',
11248        'tags',
11249        'username',
11250    ]
11251
11252    def __init__(
11253        self,
11254        bind_interface=None,
11255        egress_filter=None,
11256        healthy=None,
11257        hostname=None,
11258        id=None,
11259        name=None,
11260        password=None,
11261        port=None,
11262        port_override=None,
11263        secret_store_id=None,
11264        tags=None,
11265        username=None,
11266    ):
11267        self.bind_interface = bind_interface if bind_interface is not None else ''
11268        '''
11269         Bind interface
11270        '''
11271        self.egress_filter = egress_filter if egress_filter is not None else ''
11272        '''
11273         A filter applied to the routing logic to pin datasource to nodes.
11274        '''
11275        self.healthy = healthy if healthy is not None else False
11276        '''
11277         True if the datasource is reachable and the credentials are valid.
11278        '''
11279        self.hostname = hostname if hostname is not None else ''
11280        self.id = id if id is not None else ''
11281        '''
11282         Unique identifier of the Resource.
11283        '''
11284        self.name = name if name is not None else ''
11285        '''
11286         Unique human-readable name of the Resource.
11287        '''
11288        self.password = password if password is not None else ''
11289        self.port = port if port is not None else 0
11290        self.port_override = port_override if port_override is not None else 0
11291        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11292        '''
11293         ID of the secret store containing credentials for this resource, if any.
11294        '''
11295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11296        '''
11297         Tags is a map of key, value pairs.
11298        '''
11299        self.username = username if username is not None else ''
11300
11301    def __repr__(self):
11302        return '<sdm.SybaseIQ ' + \
11303            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11304            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11305            'healthy: ' + repr(self.healthy) + ' ' +\
11306            'hostname: ' + repr(self.hostname) + ' ' +\
11307            'id: ' + repr(self.id) + ' ' +\
11308            'name: ' + repr(self.name) + ' ' +\
11309            'password: ' + repr(self.password) + ' ' +\
11310            'port: ' + repr(self.port) + ' ' +\
11311            'port_override: ' + repr(self.port_override) + ' ' +\
11312            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11313            'tags: ' + repr(self.tags) + ' ' +\
11314            'username: ' + repr(self.username) + ' ' +\
11315            '>'
11316
11317    def to_dict(self):
11318        return {
11319            'bind_interface': self.bind_interface,
11320            'egress_filter': self.egress_filter,
11321            'healthy': self.healthy,
11322            'hostname': self.hostname,
11323            'id': self.id,
11324            'name': self.name,
11325            'password': self.password,
11326            'port': self.port,
11327            'port_override': self.port_override,
11328            'secret_store_id': self.secret_store_id,
11329            'tags': self.tags,
11330            'username': self.username,
11331        }
11332
11333    @classmethod
11334    def from_dict(cls, d):
11335        return cls(
11336            bind_interface=d.get('bind_interface'),
11337            egress_filter=d.get('egress_filter'),
11338            healthy=d.get('healthy'),
11339            hostname=d.get('hostname'),
11340            id=d.get('id'),
11341            name=d.get('name'),
11342            password=d.get('password'),
11343            port=d.get('port'),
11344            port_override=d.get('port_override'),
11345            secret_store_id=d.get('secret_store_id'),
11346            tags=d.get('tags'),
11347            username=d.get('username'),
11348        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11252    def __init__(
11253        self,
11254        bind_interface=None,
11255        egress_filter=None,
11256        healthy=None,
11257        hostname=None,
11258        id=None,
11259        name=None,
11260        password=None,
11261        port=None,
11262        port_override=None,
11263        secret_store_id=None,
11264        tags=None,
11265        username=None,
11266    ):
11267        self.bind_interface = bind_interface if bind_interface is not None else ''
11268        '''
11269         Bind interface
11270        '''
11271        self.egress_filter = egress_filter if egress_filter is not None else ''
11272        '''
11273         A filter applied to the routing logic to pin datasource to nodes.
11274        '''
11275        self.healthy = healthy if healthy is not None else False
11276        '''
11277         True if the datasource is reachable and the credentials are valid.
11278        '''
11279        self.hostname = hostname if hostname is not None else ''
11280        self.id = id if id is not None else ''
11281        '''
11282         Unique identifier of the Resource.
11283        '''
11284        self.name = name if name is not None else ''
11285        '''
11286         Unique human-readable name of the Resource.
11287        '''
11288        self.password = password if password is not None else ''
11289        self.port = port if port is not None else 0
11290        self.port_override = port_override if port_override is not None else 0
11291        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11292        '''
11293         ID of the secret store containing credentials for this resource, if any.
11294        '''
11295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11296        '''
11297         Tags is a map of key, value pairs.
11298        '''
11299        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11317    def to_dict(self):
11318        return {
11319            'bind_interface': self.bind_interface,
11320            'egress_filter': self.egress_filter,
11321            'healthy': self.healthy,
11322            'hostname': self.hostname,
11323            'id': self.id,
11324            'name': self.name,
11325            'password': self.password,
11326            'port': self.port,
11327            'port_override': self.port_override,
11328            'secret_store_id': self.secret_store_id,
11329            'tags': self.tags,
11330            'username': self.username,
11331        }
@classmethod
def from_dict(cls, d)
11333    @classmethod
11334    def from_dict(cls, d):
11335        return cls(
11336            bind_interface=d.get('bind_interface'),
11337            egress_filter=d.get('egress_filter'),
11338            healthy=d.get('healthy'),
11339            hostname=d.get('hostname'),
11340            id=d.get('id'),
11341            name=d.get('name'),
11342            password=d.get('password'),
11343            port=d.get('port'),
11344            port_override=d.get('port_override'),
11345            secret_store_id=d.get('secret_store_id'),
11346            tags=d.get('tags'),
11347            username=d.get('username'),
11348        )
class Tag:
11351class Tag:
11352    __slots__ = [
11353        'name',
11354        'value',
11355    ]
11356
11357    def __init__(
11358        self,
11359        name=None,
11360        value=None,
11361    ):
11362        self.name = name if name is not None else ''
11363        self.value = value if value is not None else ''
11364
11365    def __repr__(self):
11366        return '<sdm.Tag ' + \
11367            'name: ' + repr(self.name) + ' ' +\
11368            'value: ' + repr(self.value) + ' ' +\
11369            '>'
11370
11371    def to_dict(self):
11372        return {
11373            'name': self.name,
11374            'value': self.value,
11375        }
11376
11377    @classmethod
11378    def from_dict(cls, d):
11379        return cls(
11380            name=d.get('name'),
11381            value=d.get('value'),
11382        )
Tag(name=None, value=None)
11357    def __init__(
11358        self,
11359        name=None,
11360        value=None,
11361    ):
11362        self.name = name if name is not None else ''
11363        self.value = value if value is not None else ''
name
value
def to_dict(self)
11371    def to_dict(self):
11372        return {
11373            'name': self.name,
11374            'value': self.value,
11375        }
@classmethod
def from_dict(cls, d)
11377    @classmethod
11378    def from_dict(cls, d):
11379        return cls(
11380            name=d.get('name'),
11381            value=d.get('value'),
11382        )
class Teradata:
11385class Teradata:
11386    __slots__ = [
11387        'bind_interface',
11388        'egress_filter',
11389        'healthy',
11390        'hostname',
11391        'id',
11392        'name',
11393        'password',
11394        'port',
11395        'port_override',
11396        'secret_store_id',
11397        'tags',
11398        'username',
11399    ]
11400
11401    def __init__(
11402        self,
11403        bind_interface=None,
11404        egress_filter=None,
11405        healthy=None,
11406        hostname=None,
11407        id=None,
11408        name=None,
11409        password=None,
11410        port=None,
11411        port_override=None,
11412        secret_store_id=None,
11413        tags=None,
11414        username=None,
11415    ):
11416        self.bind_interface = bind_interface if bind_interface is not None else ''
11417        '''
11418         Bind interface
11419        '''
11420        self.egress_filter = egress_filter if egress_filter is not None else ''
11421        '''
11422         A filter applied to the routing logic to pin datasource to nodes.
11423        '''
11424        self.healthy = healthy if healthy is not None else False
11425        '''
11426         True if the datasource is reachable and the credentials are valid.
11427        '''
11428        self.hostname = hostname if hostname is not None else ''
11429        self.id = id if id is not None else ''
11430        '''
11431         Unique identifier of the Resource.
11432        '''
11433        self.name = name if name is not None else ''
11434        '''
11435         Unique human-readable name of the Resource.
11436        '''
11437        self.password = password if password is not None else ''
11438        self.port = port if port is not None else 0
11439        self.port_override = port_override if port_override is not None else 0
11440        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11441        '''
11442         ID of the secret store containing credentials for this resource, if any.
11443        '''
11444        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11445        '''
11446         Tags is a map of key, value pairs.
11447        '''
11448        self.username = username if username is not None else ''
11449
11450    def __repr__(self):
11451        return '<sdm.Teradata ' + \
11452            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11453            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11454            'healthy: ' + repr(self.healthy) + ' ' +\
11455            'hostname: ' + repr(self.hostname) + ' ' +\
11456            'id: ' + repr(self.id) + ' ' +\
11457            'name: ' + repr(self.name) + ' ' +\
11458            'password: ' + repr(self.password) + ' ' +\
11459            'port: ' + repr(self.port) + ' ' +\
11460            'port_override: ' + repr(self.port_override) + ' ' +\
11461            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11462            'tags: ' + repr(self.tags) + ' ' +\
11463            'username: ' + repr(self.username) + ' ' +\
11464            '>'
11465
11466    def to_dict(self):
11467        return {
11468            'bind_interface': self.bind_interface,
11469            'egress_filter': self.egress_filter,
11470            'healthy': self.healthy,
11471            'hostname': self.hostname,
11472            'id': self.id,
11473            'name': self.name,
11474            'password': self.password,
11475            'port': self.port,
11476            'port_override': self.port_override,
11477            'secret_store_id': self.secret_store_id,
11478            'tags': self.tags,
11479            'username': self.username,
11480        }
11481
11482    @classmethod
11483    def from_dict(cls, d):
11484        return cls(
11485            bind_interface=d.get('bind_interface'),
11486            egress_filter=d.get('egress_filter'),
11487            healthy=d.get('healthy'),
11488            hostname=d.get('hostname'),
11489            id=d.get('id'),
11490            name=d.get('name'),
11491            password=d.get('password'),
11492            port=d.get('port'),
11493            port_override=d.get('port_override'),
11494            secret_store_id=d.get('secret_store_id'),
11495            tags=d.get('tags'),
11496            username=d.get('username'),
11497        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11401    def __init__(
11402        self,
11403        bind_interface=None,
11404        egress_filter=None,
11405        healthy=None,
11406        hostname=None,
11407        id=None,
11408        name=None,
11409        password=None,
11410        port=None,
11411        port_override=None,
11412        secret_store_id=None,
11413        tags=None,
11414        username=None,
11415    ):
11416        self.bind_interface = bind_interface if bind_interface is not None else ''
11417        '''
11418         Bind interface
11419        '''
11420        self.egress_filter = egress_filter if egress_filter is not None else ''
11421        '''
11422         A filter applied to the routing logic to pin datasource to nodes.
11423        '''
11424        self.healthy = healthy if healthy is not None else False
11425        '''
11426         True if the datasource is reachable and the credentials are valid.
11427        '''
11428        self.hostname = hostname if hostname is not None else ''
11429        self.id = id if id is not None else ''
11430        '''
11431         Unique identifier of the Resource.
11432        '''
11433        self.name = name if name is not None else ''
11434        '''
11435         Unique human-readable name of the Resource.
11436        '''
11437        self.password = password if password is not None else ''
11438        self.port = port if port is not None else 0
11439        self.port_override = port_override if port_override is not None else 0
11440        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11441        '''
11442         ID of the secret store containing credentials for this resource, if any.
11443        '''
11444        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11445        '''
11446         Tags is a map of key, value pairs.
11447        '''
11448        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11466    def to_dict(self):
11467        return {
11468            'bind_interface': self.bind_interface,
11469            'egress_filter': self.egress_filter,
11470            'healthy': self.healthy,
11471            'hostname': self.hostname,
11472            'id': self.id,
11473            'name': self.name,
11474            'password': self.password,
11475            'port': self.port,
11476            'port_override': self.port_override,
11477            'secret_store_id': self.secret_store_id,
11478            'tags': self.tags,
11479            'username': self.username,
11480        }
@classmethod
def from_dict(cls, d)
11482    @classmethod
11483    def from_dict(cls, d):
11484        return cls(
11485            bind_interface=d.get('bind_interface'),
11486            egress_filter=d.get('egress_filter'),
11487            healthy=d.get('healthy'),
11488            hostname=d.get('hostname'),
11489            id=d.get('id'),
11490            name=d.get('name'),
11491            password=d.get('password'),
11492            port=d.get('port'),
11493            port_override=d.get('port_override'),
11494            secret_store_id=d.get('secret_store_id'),
11495            tags=d.get('tags'),
11496            username=d.get('username'),
11497        )
class UpdateResponseMetadata:
11500class UpdateResponseMetadata:
11501    '''
11502         UpdateResponseMetadata is reserved for future use.
11503    '''
11504    __slots__ = []
11505
11506    def __init__(self, ):
11507        pass
11508
11509    def __repr__(self):
11510        return '<sdm.UpdateResponseMetadata ' + \
11511            '>'
11512
11513    def to_dict(self):
11514        return {}
11515
11516    @classmethod
11517    def from_dict(cls, d):
11518        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
11506    def __init__(self, ):
11507        pass
def to_dict(self)
11513    def to_dict(self):
11514        return {}
@classmethod
def from_dict(cls, d)
11516    @classmethod
11517    def from_dict(cls, d):
11518        return cls()
class User:
11521class User:
11522    '''
11523         A User can connect to resources they are granted directly, or granted
11524     via roles.
11525    '''
11526    __slots__ = [
11527        'email',
11528        'first_name',
11529        'id',
11530        'last_name',
11531        'suspended',
11532        'tags',
11533    ]
11534
11535    def __init__(
11536        self,
11537        email=None,
11538        first_name=None,
11539        id=None,
11540        last_name=None,
11541        suspended=None,
11542        tags=None,
11543    ):
11544        self.email = email if email is not None else ''
11545        '''
11546         The User's email address. Must be unique.
11547        '''
11548        self.first_name = first_name if first_name is not None else ''
11549        '''
11550         The User's first name.
11551        '''
11552        self.id = id if id is not None else ''
11553        '''
11554         Unique identifier of the User.
11555        '''
11556        self.last_name = last_name if last_name is not None else ''
11557        '''
11558         The User's last name.
11559        '''
11560        self.suspended = suspended if suspended is not None else False
11561        '''
11562         The User's suspended state.
11563        '''
11564        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11565        '''
11566         Tags is a map of key, value pairs.
11567        '''
11568
11569    def __repr__(self):
11570        return '<sdm.User ' + \
11571            'email: ' + repr(self.email) + ' ' +\
11572            'first_name: ' + repr(self.first_name) + ' ' +\
11573            'id: ' + repr(self.id) + ' ' +\
11574            'last_name: ' + repr(self.last_name) + ' ' +\
11575            'suspended: ' + repr(self.suspended) + ' ' +\
11576            'tags: ' + repr(self.tags) + ' ' +\
11577            '>'
11578
11579    def to_dict(self):
11580        return {
11581            'email': self.email,
11582            'first_name': self.first_name,
11583            'id': self.id,
11584            'last_name': self.last_name,
11585            'suspended': self.suspended,
11586            'tags': self.tags,
11587        }
11588
11589    @classmethod
11590    def from_dict(cls, d):
11591        return cls(
11592            email=d.get('email'),
11593            first_name=d.get('first_name'),
11594            id=d.get('id'),
11595            last_name=d.get('last_name'),
11596            suspended=d.get('suspended'),
11597            tags=d.get('tags'),
11598        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, first_name=None, id=None, last_name=None, suspended=None, tags=None)
11535    def __init__(
11536        self,
11537        email=None,
11538        first_name=None,
11539        id=None,
11540        last_name=None,
11541        suspended=None,
11542        tags=None,
11543    ):
11544        self.email = email if email is not None else ''
11545        '''
11546         The User's email address. Must be unique.
11547        '''
11548        self.first_name = first_name if first_name is not None else ''
11549        '''
11550         The User's first name.
11551        '''
11552        self.id = id if id is not None else ''
11553        '''
11554         Unique identifier of the User.
11555        '''
11556        self.last_name = last_name if last_name is not None else ''
11557        '''
11558         The User's last name.
11559        '''
11560        self.suspended = suspended if suspended is not None else False
11561        '''
11562         The User's suspended state.
11563        '''
11564        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11565        '''
11566         Tags is a map of key, value pairs.
11567        '''
email

The User's email address. Must be unique.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
11579    def to_dict(self):
11580        return {
11581            'email': self.email,
11582            'first_name': self.first_name,
11583            'id': self.id,
11584            'last_name': self.last_name,
11585            'suspended': self.suspended,
11586            'tags': self.tags,
11587        }
@classmethod
def from_dict(cls, d)
11589    @classmethod
11590    def from_dict(cls, d):
11591        return cls(
11592            email=d.get('email'),
11593            first_name=d.get('first_name'),
11594            id=d.get('id'),
11595            last_name=d.get('last_name'),
11596            suspended=d.get('suspended'),
11597            tags=d.get('tags'),
11598        )
class VaultAppRoleStore:
11601class VaultAppRoleStore:
11602    __slots__ = [
11603        'id',
11604        'name',
11605        'namespace',
11606        'server_address',
11607        'tags',
11608    ]
11609
11610    def __init__(
11611        self,
11612        id=None,
11613        name=None,
11614        namespace=None,
11615        server_address=None,
11616        tags=None,
11617    ):
11618        self.id = id if id is not None else ''
11619        '''
11620         Unique identifier of the SecretStore.
11621        '''
11622        self.name = name if name is not None else ''
11623        '''
11624         Unique human-readable name of the SecretStore.
11625        '''
11626        self.namespace = namespace if namespace is not None else ''
11627        self.server_address = server_address if server_address is not None else ''
11628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11629        '''
11630         Tags is a map of key, value pairs.
11631        '''
11632
11633    def __repr__(self):
11634        return '<sdm.VaultAppRoleStore ' + \
11635            'id: ' + repr(self.id) + ' ' +\
11636            'name: ' + repr(self.name) + ' ' +\
11637            'namespace: ' + repr(self.namespace) + ' ' +\
11638            'server_address: ' + repr(self.server_address) + ' ' +\
11639            'tags: ' + repr(self.tags) + ' ' +\
11640            '>'
11641
11642    def to_dict(self):
11643        return {
11644            'id': self.id,
11645            'name': self.name,
11646            'namespace': self.namespace,
11647            'server_address': self.server_address,
11648            'tags': self.tags,
11649        }
11650
11651    @classmethod
11652    def from_dict(cls, d):
11653        return cls(
11654            id=d.get('id'),
11655            name=d.get('name'),
11656            namespace=d.get('namespace'),
11657            server_address=d.get('server_address'),
11658            tags=d.get('tags'),
11659        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
11610    def __init__(
11611        self,
11612        id=None,
11613        name=None,
11614        namespace=None,
11615        server_address=None,
11616        tags=None,
11617    ):
11618        self.id = id if id is not None else ''
11619        '''
11620         Unique identifier of the SecretStore.
11621        '''
11622        self.name = name if name is not None else ''
11623        '''
11624         Unique human-readable name of the SecretStore.
11625        '''
11626        self.namespace = namespace if namespace is not None else ''
11627        self.server_address = server_address if server_address is not None else ''
11628        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11629        '''
11630         Tags is a map of key, value pairs.
11631        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
11642    def to_dict(self):
11643        return {
11644            'id': self.id,
11645            'name': self.name,
11646            'namespace': self.namespace,
11647            'server_address': self.server_address,
11648            'tags': self.tags,
11649        }
@classmethod
def from_dict(cls, d)
11651    @classmethod
11652    def from_dict(cls, d):
11653        return cls(
11654            id=d.get('id'),
11655            name=d.get('name'),
11656            namespace=d.get('namespace'),
11657            server_address=d.get('server_address'),
11658            tags=d.get('tags'),
11659        )
class VaultTLSStore:
11662class VaultTLSStore:
11663    __slots__ = [
11664        'ca_cert_path',
11665        'client_cert_path',
11666        'client_key_path',
11667        'id',
11668        'name',
11669        'namespace',
11670        'server_address',
11671        'tags',
11672    ]
11673
11674    def __init__(
11675        self,
11676        ca_cert_path=None,
11677        client_cert_path=None,
11678        client_key_path=None,
11679        id=None,
11680        name=None,
11681        namespace=None,
11682        server_address=None,
11683        tags=None,
11684    ):
11685        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
11686        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
11687        self.client_key_path = client_key_path if client_key_path is not None else ''
11688        self.id = id if id is not None else ''
11689        '''
11690         Unique identifier of the SecretStore.
11691        '''
11692        self.name = name if name is not None else ''
11693        '''
11694         Unique human-readable name of the SecretStore.
11695        '''
11696        self.namespace = namespace if namespace is not None else ''
11697        self.server_address = server_address if server_address is not None else ''
11698        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11699        '''
11700         Tags is a map of key, value pairs.
11701        '''
11702
11703    def __repr__(self):
11704        return '<sdm.VaultTLSStore ' + \
11705            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
11706            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
11707            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
11708            'id: ' + repr(self.id) + ' ' +\
11709            'name: ' + repr(self.name) + ' ' +\
11710            'namespace: ' + repr(self.namespace) + ' ' +\
11711            'server_address: ' + repr(self.server_address) + ' ' +\
11712            'tags: ' + repr(self.tags) + ' ' +\
11713            '>'
11714
11715    def to_dict(self):
11716        return {
11717            'ca_cert_path': self.ca_cert_path,
11718            'client_cert_path': self.client_cert_path,
11719            'client_key_path': self.client_key_path,
11720            'id': self.id,
11721            'name': self.name,
11722            'namespace': self.namespace,
11723            'server_address': self.server_address,
11724            'tags': self.tags,
11725        }
11726
11727    @classmethod
11728    def from_dict(cls, d):
11729        return cls(
11730            ca_cert_path=d.get('ca_cert_path'),
11731            client_cert_path=d.get('client_cert_path'),
11732            client_key_path=d.get('client_key_path'),
11733            id=d.get('id'),
11734            name=d.get('name'),
11735            namespace=d.get('namespace'),
11736            server_address=d.get('server_address'),
11737            tags=d.get('tags'),
11738        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
11674    def __init__(
11675        self,
11676        ca_cert_path=None,
11677        client_cert_path=None,
11678        client_key_path=None,
11679        id=None,
11680        name=None,
11681        namespace=None,
11682        server_address=None,
11683        tags=None,
11684    ):
11685        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
11686        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
11687        self.client_key_path = client_key_path if client_key_path is not None else ''
11688        self.id = id if id is not None else ''
11689        '''
11690         Unique identifier of the SecretStore.
11691        '''
11692        self.name = name if name is not None else ''
11693        '''
11694         Unique human-readable name of the SecretStore.
11695        '''
11696        self.namespace = namespace if namespace is not None else ''
11697        self.server_address = server_address if server_address is not None else ''
11698        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11699        '''
11700         Tags is a map of key, value pairs.
11701        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
11715    def to_dict(self):
11716        return {
11717            'ca_cert_path': self.ca_cert_path,
11718            'client_cert_path': self.client_cert_path,
11719            'client_key_path': self.client_key_path,
11720            'id': self.id,
11721            'name': self.name,
11722            'namespace': self.namespace,
11723            'server_address': self.server_address,
11724            'tags': self.tags,
11725        }
@classmethod
def from_dict(cls, d)
11727    @classmethod
11728    def from_dict(cls, d):
11729        return cls(
11730            ca_cert_path=d.get('ca_cert_path'),
11731            client_cert_path=d.get('client_cert_path'),
11732            client_key_path=d.get('client_key_path'),
11733            id=d.get('id'),
11734            name=d.get('name'),
11735            namespace=d.get('namespace'),
11736            server_address=d.get('server_address'),
11737            tags=d.get('tags'),
11738        )
class VaultTokenStore:
11741class VaultTokenStore:
11742    __slots__ = [
11743        'id',
11744        'name',
11745        'namespace',
11746        'server_address',
11747        'tags',
11748    ]
11749
11750    def __init__(
11751        self,
11752        id=None,
11753        name=None,
11754        namespace=None,
11755        server_address=None,
11756        tags=None,
11757    ):
11758        self.id = id if id is not None else ''
11759        '''
11760         Unique identifier of the SecretStore.
11761        '''
11762        self.name = name if name is not None else ''
11763        '''
11764         Unique human-readable name of the SecretStore.
11765        '''
11766        self.namespace = namespace if namespace is not None else ''
11767        self.server_address = server_address if server_address is not None else ''
11768        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11769        '''
11770         Tags is a map of key, value pairs.
11771        '''
11772
11773    def __repr__(self):
11774        return '<sdm.VaultTokenStore ' + \
11775            'id: ' + repr(self.id) + ' ' +\
11776            'name: ' + repr(self.name) + ' ' +\
11777            'namespace: ' + repr(self.namespace) + ' ' +\
11778            'server_address: ' + repr(self.server_address) + ' ' +\
11779            'tags: ' + repr(self.tags) + ' ' +\
11780            '>'
11781
11782    def to_dict(self):
11783        return {
11784            'id': self.id,
11785            'name': self.name,
11786            'namespace': self.namespace,
11787            'server_address': self.server_address,
11788            'tags': self.tags,
11789        }
11790
11791    @classmethod
11792    def from_dict(cls, d):
11793        return cls(
11794            id=d.get('id'),
11795            name=d.get('name'),
11796            namespace=d.get('namespace'),
11797            server_address=d.get('server_address'),
11798            tags=d.get('tags'),
11799        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
11750    def __init__(
11751        self,
11752        id=None,
11753        name=None,
11754        namespace=None,
11755        server_address=None,
11756        tags=None,
11757    ):
11758        self.id = id if id is not None else ''
11759        '''
11760         Unique identifier of the SecretStore.
11761        '''
11762        self.name = name if name is not None else ''
11763        '''
11764         Unique human-readable name of the SecretStore.
11765        '''
11766        self.namespace = namespace if namespace is not None else ''
11767        self.server_address = server_address if server_address is not None else ''
11768        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11769        '''
11770         Tags is a map of key, value pairs.
11771        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
11782    def to_dict(self):
11783        return {
11784            'id': self.id,
11785            'name': self.name,
11786            'namespace': self.namespace,
11787            'server_address': self.server_address,
11788            'tags': self.tags,
11789        }
@classmethod
def from_dict(cls, d)
11791    @classmethod
11792    def from_dict(cls, d):
11793        return cls(
11794            id=d.get('id'),
11795            name=d.get('name'),
11796            namespace=d.get('namespace'),
11797            server_address=d.get('server_address'),
11798            tags=d.get('tags'),
11799        )